106765 строки
5.0 MiB
106765 строки
5.0 MiB
/*! *****************************************************************************
|
|
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 __defProp = Object.defineProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
|
|
// src/compiler/corePublic.ts
|
|
var versionMajorMinor = "5.0";
|
|
var version = `${versionMajorMinor}.0-dev`;
|
|
|
|
// src/compiler/core.ts
|
|
var emptyArray = [];
|
|
var emptyMap = /* @__PURE__ */ new Map();
|
|
function length(array) {
|
|
return array ? array.length : 0;
|
|
}
|
|
function forEach(array, callback) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const result = callback(array[i], i);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstDefined(array, callback) {
|
|
if (array === void 0) {
|
|
return void 0;
|
|
}
|
|
for (let i = 0; i < array.length; i++) {
|
|
const result = callback(array[i], i);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstDefinedIterator(iter, callback) {
|
|
while (true) {
|
|
const iterResult = iter.next();
|
|
if (iterResult.done) {
|
|
return void 0;
|
|
}
|
|
const result = callback(iterResult.value);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function reduceLeftIterator(iterator, f, initial) {
|
|
let result = initial;
|
|
if (iterator) {
|
|
for (let step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) {
|
|
result = f(result, step.value, pos);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function zipWith(arrayA, arrayB, callback) {
|
|
const result = [];
|
|
Debug.assertEqual(arrayA.length, arrayB.length);
|
|
for (let i = 0; i < arrayA.length; i++) {
|
|
result.push(callback(arrayA[i], arrayB[i], i));
|
|
}
|
|
return result;
|
|
}
|
|
function every(array, callback) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (!callback(array[i], i)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function find(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return void 0;
|
|
for (let i = startIndex != null ? startIndex : 0; i < array.length; i++) {
|
|
const value = array[i];
|
|
if (predicate(value, i)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function findLast(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return void 0;
|
|
for (let i = startIndex != null ? startIndex : array.length - 1; i >= 0; i--) {
|
|
const value = array[i];
|
|
if (predicate(value, i)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function findIndex(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return -1;
|
|
for (let i = startIndex != null ? startIndex : 0; i < array.length; i++) {
|
|
if (predicate(array[i], i)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function findLastIndex(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return -1;
|
|
for (let i = startIndex != null ? startIndex : array.length - 1; i >= 0; i--) {
|
|
if (predicate(array[i], i)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function contains(array, value, equalityComparer = equateValues) {
|
|
if (array) {
|
|
for (const v of array) {
|
|
if (equalityComparer(v, value)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function arraysEqual(a, b, equalityComparer = equateValues) {
|
|
return a.length === b.length && a.every((x, i) => equalityComparer(x, b[i]));
|
|
}
|
|
function indexOfAnyCharCode(text, charCodes, start) {
|
|
for (let i = start || 0; i < text.length; i++) {
|
|
if (contains(charCodes, text.charCodeAt(i))) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function countWhere(array, predicate) {
|
|
let count = 0;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = array[i];
|
|
if (predicate(v, i)) {
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
function filter(array, f) {
|
|
if (array) {
|
|
const len = array.length;
|
|
let i = 0;
|
|
while (i < len && f(array[i]))
|
|
i++;
|
|
if (i < len) {
|
|
const result = array.slice(0, i);
|
|
i++;
|
|
while (i < len) {
|
|
const item = array[i];
|
|
if (f(item)) {
|
|
result.push(item);
|
|
}
|
|
i++;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function filterMutate(array, f) {
|
|
let outIndex = 0;
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (f(array[i], i, array)) {
|
|
array[outIndex] = array[i];
|
|
outIndex++;
|
|
}
|
|
}
|
|
array.length = outIndex;
|
|
}
|
|
function clear(array) {
|
|
array.length = 0;
|
|
}
|
|
function map(array, f) {
|
|
let result;
|
|
if (array) {
|
|
result = [];
|
|
for (let i = 0; i < array.length; i++) {
|
|
result.push(f(array[i], i));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapIterator(iter, mapFn) {
|
|
return {
|
|
next() {
|
|
const iterRes = iter.next();
|
|
return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false };
|
|
}
|
|
};
|
|
}
|
|
function sameMap(array, f) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const item = array[i];
|
|
const mapped = f(item, i);
|
|
if (item !== mapped) {
|
|
const result = array.slice(0, i);
|
|
result.push(mapped);
|
|
for (i++; i < array.length; i++) {
|
|
result.push(f(array[i], i));
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function flatten(array) {
|
|
const result = [];
|
|
for (const v of array) {
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
addRange(result, v);
|
|
} else {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function flatMap(array, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = mapfn(array[i], i);
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
result = addRange(result, v);
|
|
} else {
|
|
result = append(result, v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function flatMapToMutable(array, mapfn) {
|
|
const result = [];
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = mapfn(array[i], i);
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
addRange(result, v);
|
|
} else {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function sameFlatMap(array, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const item = array[i];
|
|
const 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;
|
|
}
|
|
function mapDefined(array, mapFn) {
|
|
const result = [];
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const mapped = mapFn(array[i], i);
|
|
if (mapped !== void 0) {
|
|
result.push(mapped);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapDefinedIterator(iter, mapFn) {
|
|
return {
|
|
next() {
|
|
while (true) {
|
|
const res = iter.next();
|
|
if (res.done) {
|
|
return res;
|
|
}
|
|
const value = mapFn(res.value);
|
|
if (value !== void 0) {
|
|
return { value, done: false };
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function getOrUpdate(map2, key, callback) {
|
|
if (map2.has(key)) {
|
|
return map2.get(key);
|
|
}
|
|
const value = callback();
|
|
map2.set(key, value);
|
|
return value;
|
|
}
|
|
function tryAddToSet(set, value) {
|
|
if (!set.has(value)) {
|
|
set.add(value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
var emptyIterator = { next: () => ({ value: void 0, done: true }) };
|
|
function spanMap(array, keyfn, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
result = [];
|
|
const len = array.length;
|
|
let previousKey;
|
|
let key;
|
|
let start = 0;
|
|
let pos = 0;
|
|
while (start < len) {
|
|
while (pos < len) {
|
|
const value = array[pos];
|
|
key = keyfn(value, pos);
|
|
if (pos === 0) {
|
|
previousKey = key;
|
|
} else if (key !== previousKey) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
if (start < pos) {
|
|
const v = mapfn(array.slice(start, pos), previousKey, start, pos);
|
|
if (v) {
|
|
result.push(v);
|
|
}
|
|
start = pos;
|
|
}
|
|
previousKey = key;
|
|
pos++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function some(array, predicate) {
|
|
if (array) {
|
|
if (predicate) {
|
|
for (const v of array) {
|
|
if (predicate(v)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
return array.length > 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getRangesWhere(arr, pred, cb) {
|
|
let start;
|
|
for (let i = 0; i < arr.length; i++) {
|
|
if (pred(arr[i])) {
|
|
start = start === void 0 ? i : start;
|
|
} else {
|
|
if (start !== void 0) {
|
|
cb(start, i);
|
|
start = void 0;
|
|
}
|
|
}
|
|
}
|
|
if (start !== void 0)
|
|
cb(start, arr.length);
|
|
}
|
|
function concatenate(array1, array2) {
|
|
if (!some(array2))
|
|
return array1;
|
|
if (!some(array1))
|
|
return array2;
|
|
return [...array1, ...array2];
|
|
}
|
|
function selectIndex(_, i) {
|
|
return i;
|
|
}
|
|
function indicesOf(array) {
|
|
return array.map(selectIndex);
|
|
}
|
|
function deduplicateRelational(array, equalityComparer, comparer) {
|
|
const indices = indicesOf(array);
|
|
stableSortIndices(array, indices, comparer);
|
|
let last2 = array[indices[0]];
|
|
const deduplicated = [indices[0]];
|
|
for (let i = 1; i < indices.length; i++) {
|
|
const index = indices[i];
|
|
const item = array[index];
|
|
if (!equalityComparer(last2, item)) {
|
|
deduplicated.push(index);
|
|
last2 = item;
|
|
}
|
|
}
|
|
deduplicated.sort();
|
|
return deduplicated.map((i) => array[i]);
|
|
}
|
|
function deduplicateEquality(array, equalityComparer) {
|
|
const result = [];
|
|
for (const item of array) {
|
|
pushIfUnique(result, item, equalityComparer);
|
|
}
|
|
return result;
|
|
}
|
|
function deduplicate(array, equalityComparer, comparer) {
|
|
return array.length === 0 ? [] : array.length === 1 ? array.slice() : comparer ? deduplicateRelational(array, equalityComparer, comparer) : deduplicateEquality(array, equalityComparer);
|
|
}
|
|
function deduplicateSorted(array, comparer) {
|
|
if (array.length === 0)
|
|
return emptyArray;
|
|
let last2 = array[0];
|
|
const deduplicated = [last2];
|
|
for (let i = 1; i < array.length; i++) {
|
|
const next = array[i];
|
|
switch (comparer(next, last2)) {
|
|
case true:
|
|
case 0 /* EqualTo */:
|
|
continue;
|
|
case -1 /* LessThan */:
|
|
return Debug.fail("Array is unsorted.");
|
|
}
|
|
deduplicated.push(last2 = next);
|
|
}
|
|
return deduplicated;
|
|
}
|
|
function insertSorted(array, insert, compare, allowDuplicates) {
|
|
if (array.length === 0) {
|
|
array.push(insert);
|
|
return true;
|
|
}
|
|
const 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;
|
|
}
|
|
function sortAndDeduplicate(array, comparer, equalityComparer) {
|
|
return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
|
|
}
|
|
function arrayIsEqualTo(array1, array2, equalityComparer = equateValues) {
|
|
if (!array1 || !array2) {
|
|
return array1 === array2;
|
|
}
|
|
if (array1.length !== array2.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < array1.length; i++) {
|
|
if (!equalityComparer(array1[i], array2[i], i)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function compact(array) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = array[i];
|
|
if (result || !v) {
|
|
if (!result) {
|
|
result = array.slice(0, i);
|
|
}
|
|
if (v) {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result || array;
|
|
}
|
|
function relativeComplement(arrayA, arrayB, comparer) {
|
|
if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)
|
|
return arrayB;
|
|
const result = [];
|
|
loopB:
|
|
for (let offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
|
|
if (offsetB > 0) {
|
|
Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0 /* EqualTo */);
|
|
}
|
|
loopA:
|
|
for (const startA = offsetA; offsetA < arrayA.length; offsetA++) {
|
|
if (offsetA > startA) {
|
|
Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0 /* EqualTo */);
|
|
}
|
|
switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
|
|
case -1 /* LessThan */:
|
|
result.push(arrayB[offsetB]);
|
|
continue loopB;
|
|
case 0 /* EqualTo */:
|
|
continue loopB;
|
|
case 1 /* GreaterThan */:
|
|
continue loopA;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function sum(array, prop) {
|
|
let result = 0;
|
|
for (const v of array) {
|
|
result += v[prop];
|
|
}
|
|
return result;
|
|
}
|
|
function append(to, value) {
|
|
if (value === void 0)
|
|
return to;
|
|
if (to === void 0)
|
|
return [value];
|
|
to.push(value);
|
|
return to;
|
|
}
|
|
function toOffset(array, offset) {
|
|
return offset < 0 ? array.length + offset : offset;
|
|
}
|
|
function addRange(to, from, start, end) {
|
|
if (from === void 0 || from.length === 0)
|
|
return to;
|
|
if (to === void 0)
|
|
return from.slice(start, end);
|
|
start = start === void 0 ? 0 : toOffset(from, start);
|
|
end = end === void 0 ? from.length : toOffset(from, end);
|
|
for (let i = start; i < end && i < from.length; i++) {
|
|
if (from[i] !== void 0) {
|
|
to.push(from[i]);
|
|
}
|
|
}
|
|
return to;
|
|
}
|
|
function pushIfUnique(array, toAdd, equalityComparer) {
|
|
if (contains(array, toAdd, equalityComparer)) {
|
|
return false;
|
|
} else {
|
|
array.push(toAdd);
|
|
return true;
|
|
}
|
|
}
|
|
function appendIfUnique(array, toAdd, equalityComparer) {
|
|
if (array) {
|
|
pushIfUnique(array, toAdd, equalityComparer);
|
|
return array;
|
|
} else {
|
|
return [toAdd];
|
|
}
|
|
}
|
|
function stableSortIndices(array, indices, comparer) {
|
|
indices.sort((x, y) => comparer(array[x], array[y]) || compareValues(x, y));
|
|
}
|
|
function sort(array, comparer) {
|
|
return array.length === 0 ? array : array.slice().sort(comparer);
|
|
}
|
|
function stableSort(array, comparer) {
|
|
const indices = indicesOf(array);
|
|
stableSortIndices(array, indices, comparer);
|
|
return indices.map((i) => array[i]);
|
|
}
|
|
function rangeEquals(array1, array2, pos, end) {
|
|
while (pos < end) {
|
|
if (array1[pos] !== array2[pos]) {
|
|
return false;
|
|
}
|
|
pos++;
|
|
}
|
|
return true;
|
|
}
|
|
function elementAt(array, offset) {
|
|
if (array) {
|
|
offset = toOffset(array, offset);
|
|
if (offset < array.length) {
|
|
return array[offset];
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstOrUndefined(array) {
|
|
return array === void 0 || array.length === 0 ? void 0 : array[0];
|
|
}
|
|
function first(array) {
|
|
Debug.assert(array.length !== 0);
|
|
return array[0];
|
|
}
|
|
function lastOrUndefined(array) {
|
|
return array === void 0 || array.length === 0 ? void 0 : array[array.length - 1];
|
|
}
|
|
function last(array) {
|
|
Debug.assert(array.length !== 0);
|
|
return array[array.length - 1];
|
|
}
|
|
function singleOrUndefined(array) {
|
|
return array && array.length === 1 ? array[0] : void 0;
|
|
}
|
|
function singleOrMany(array) {
|
|
return array && array.length === 1 ? array[0] : array;
|
|
}
|
|
function replaceElement(array, index, value) {
|
|
const result = array.slice(0);
|
|
result[index] = value;
|
|
return result;
|
|
}
|
|
function binarySearch(array, value, keySelector, keyComparer, offset) {
|
|
return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset);
|
|
}
|
|
function binarySearchKey(array, key, keySelector, keyComparer, offset) {
|
|
if (!some(array)) {
|
|
return -1;
|
|
}
|
|
let low = offset || 0;
|
|
let high = array.length - 1;
|
|
while (low <= high) {
|
|
const middle = low + (high - low >> 1);
|
|
const midKey = keySelector(array[middle], middle);
|
|
switch (keyComparer(midKey, key)) {
|
|
case -1 /* LessThan */:
|
|
low = middle + 1;
|
|
break;
|
|
case 0 /* EqualTo */:
|
|
return middle;
|
|
case 1 /* GreaterThan */:
|
|
high = middle - 1;
|
|
break;
|
|
}
|
|
}
|
|
return ~low;
|
|
}
|
|
function reduceLeft(array, f, initial, start, count) {
|
|
if (array && array.length > 0) {
|
|
const size = array.length;
|
|
if (size > 0) {
|
|
let pos = start === void 0 || start < 0 ? 0 : start;
|
|
const end = count === void 0 || pos + count > size - 1 ? size - 1 : pos + count;
|
|
let result;
|
|
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;
|
|
}
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function hasProperty(map2, key) {
|
|
return hasOwnProperty.call(map2, key);
|
|
}
|
|
function getOwnKeys(map2) {
|
|
const keys = [];
|
|
for (const key in map2) {
|
|
if (hasOwnProperty.call(map2, key)) {
|
|
keys.push(key);
|
|
}
|
|
}
|
|
return keys;
|
|
}
|
|
function getOwnValues(collection) {
|
|
const values = [];
|
|
for (const key in collection) {
|
|
if (hasOwnProperty.call(collection, key)) {
|
|
values.push(collection[key]);
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
var _entries = Object.entries || ((obj) => {
|
|
const keys = getOwnKeys(obj);
|
|
const result = Array(keys.length);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
result[i] = [keys[i], obj[keys[i]]];
|
|
}
|
|
return result;
|
|
});
|
|
function getEntries(obj) {
|
|
return obj ? _entries(obj) : [];
|
|
}
|
|
function arrayOf(count, f) {
|
|
const result = new Array(count);
|
|
for (let i = 0; i < count; i++) {
|
|
result[i] = f(i);
|
|
}
|
|
return result;
|
|
}
|
|
function arrayFrom(iterator, map2) {
|
|
const result = [];
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
result.push(map2 ? map2(iterResult.value) : iterResult.value);
|
|
}
|
|
return result;
|
|
}
|
|
function assign(t, ...args) {
|
|
for (const arg of args) {
|
|
if (arg === void 0)
|
|
continue;
|
|
for (const p in arg) {
|
|
if (hasProperty(arg, p)) {
|
|
t[p] = arg[p];
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function equalOwnProperties(left, right, equalityComparer = equateValues) {
|
|
if (left === right)
|
|
return true;
|
|
if (!left || !right)
|
|
return false;
|
|
for (const key in left) {
|
|
if (hasOwnProperty.call(left, key)) {
|
|
if (!hasOwnProperty.call(right, key))
|
|
return false;
|
|
if (!equalityComparer(left[key], right[key]))
|
|
return false;
|
|
}
|
|
}
|
|
for (const key in right) {
|
|
if (hasOwnProperty.call(right, key)) {
|
|
if (!hasOwnProperty.call(left, key))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function arrayToMap(array, makeKey, makeValue = identity) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
for (const value of array) {
|
|
const key = makeKey(value);
|
|
if (key !== void 0)
|
|
result.set(key, makeValue(value));
|
|
}
|
|
return result;
|
|
}
|
|
function arrayToMultiMap(values, makeKey, makeValue = identity) {
|
|
const result = createMultiMap();
|
|
for (const value of values) {
|
|
result.add(makeKey(value), makeValue(value));
|
|
}
|
|
return result;
|
|
}
|
|
function group(values, getGroupId, resultSelector = identity) {
|
|
return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector);
|
|
}
|
|
function clone(object) {
|
|
const result = {};
|
|
for (const id in object) {
|
|
if (hasOwnProperty.call(object, id)) {
|
|
result[id] = object[id];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function extend(first2, second) {
|
|
const result = {};
|
|
for (const id in second) {
|
|
if (hasOwnProperty.call(second, id)) {
|
|
result[id] = second[id];
|
|
}
|
|
}
|
|
for (const id in first2) {
|
|
if (hasOwnProperty.call(first2, id)) {
|
|
result[id] = first2[id];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function copyProperties(first2, second) {
|
|
for (const id in second) {
|
|
if (hasOwnProperty.call(second, id)) {
|
|
first2[id] = second[id];
|
|
}
|
|
}
|
|
}
|
|
function maybeBind(obj, fn) {
|
|
return fn ? fn.bind(obj) : void 0;
|
|
}
|
|
function createMultiMap() {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
map2.add = multiMapAdd;
|
|
map2.remove = multiMapRemove;
|
|
return map2;
|
|
}
|
|
function multiMapAdd(key, value) {
|
|
let values = this.get(key);
|
|
if (values) {
|
|
values.push(value);
|
|
} else {
|
|
this.set(key, values = [value]);
|
|
}
|
|
return values;
|
|
}
|
|
function multiMapRemove(key, value) {
|
|
const values = this.get(key);
|
|
if (values) {
|
|
unorderedRemoveItem(values, value);
|
|
if (!values.length) {
|
|
this.delete(key);
|
|
}
|
|
}
|
|
}
|
|
function createUnderscoreEscapedMultiMap() {
|
|
return createMultiMap();
|
|
}
|
|
function createQueue(items) {
|
|
const elements = (items == null ? void 0 : items.slice()) || [];
|
|
let headIndex = 0;
|
|
function isEmpty() {
|
|
return headIndex === elements.length;
|
|
}
|
|
function enqueue(...items2) {
|
|
elements.push(...items2);
|
|
}
|
|
function dequeue() {
|
|
if (isEmpty()) {
|
|
throw new Error("Queue is empty");
|
|
}
|
|
const result = elements[headIndex];
|
|
elements[headIndex] = void 0;
|
|
headIndex++;
|
|
if (headIndex > 100 && headIndex > elements.length >> 1) {
|
|
const newLength = elements.length - headIndex;
|
|
elements.copyWithin(0, headIndex);
|
|
elements.length = newLength;
|
|
headIndex = 0;
|
|
}
|
|
return result;
|
|
}
|
|
return {
|
|
enqueue,
|
|
dequeue,
|
|
isEmpty
|
|
};
|
|
}
|
|
function isArray(value) {
|
|
return Array.isArray ? Array.isArray(value) : value instanceof Array;
|
|
}
|
|
function toArray(value) {
|
|
return isArray(value) ? value : [value];
|
|
}
|
|
function isString(text) {
|
|
return typeof text === "string";
|
|
}
|
|
function isNumber(x) {
|
|
return typeof x === "number";
|
|
}
|
|
function tryCast(value, test) {
|
|
return value !== void 0 && test(value) ? value : void 0;
|
|
}
|
|
function cast(value, test) {
|
|
if (value !== void 0 && test(value))
|
|
return value;
|
|
return Debug.fail(`Invalid cast. The supplied value ${value} did not pass the test '${Debug.getFunctionName(test)}'.`);
|
|
}
|
|
function noop(_) {
|
|
}
|
|
var noopPush = {
|
|
push: noop,
|
|
length: 0
|
|
};
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
function returnUndefined() {
|
|
return void 0;
|
|
}
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
function toLowerCase(x) {
|
|
return x.toLowerCase();
|
|
}
|
|
var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
|
|
function toFileNameLowerCase(x) {
|
|
return fileNameLowerCaseRegExp.test(x) ? x.replace(fileNameLowerCaseRegExp, toLowerCase) : x;
|
|
}
|
|
function notImplemented() {
|
|
throw new Error("Not implemented");
|
|
}
|
|
function memoize(callback) {
|
|
let value;
|
|
return () => {
|
|
if (callback) {
|
|
value = callback();
|
|
callback = void 0;
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
function memoizeOne(callback) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
return (arg) => {
|
|
const key = `${typeof arg}:${arg}`;
|
|
let value = map2.get(key);
|
|
if (value === void 0 && !map2.has(key)) {
|
|
value = callback(arg);
|
|
map2.set(key, value);
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
function equateValues(a, b) {
|
|
return a === b;
|
|
}
|
|
function equateStringsCaseInsensitive(a, b) {
|
|
return a === b || a !== void 0 && b !== void 0 && a.toUpperCase() === b.toUpperCase();
|
|
}
|
|
function equateStringsCaseSensitive(a, b) {
|
|
return equateValues(a, b);
|
|
}
|
|
function compareComparableValues(a, b) {
|
|
return a === b ? 0 /* EqualTo */ : a === void 0 ? -1 /* LessThan */ : b === void 0 ? 1 /* GreaterThan */ : a < b ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
}
|
|
function compareValues(a, b) {
|
|
return compareComparableValues(a, b);
|
|
}
|
|
function min(items, compare) {
|
|
return reduceLeft(items, (x, y) => compare(x, y) === -1 /* LessThan */ ? x : y);
|
|
}
|
|
function compareStringsCaseInsensitive(a, b) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
a = a.toUpperCase();
|
|
b = b.toUpperCase();
|
|
return a < b ? -1 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
function compareStringsCaseSensitive(a, b) {
|
|
return compareComparableValues(a, b);
|
|
}
|
|
function getStringComparer(ignoreCase) {
|
|
return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
|
|
}
|
|
var createUIStringComparer = (() => {
|
|
let defaultComparer;
|
|
let enUSComparer;
|
|
const stringComparerFactory = getStringComparerFactory();
|
|
return createStringComparer;
|
|
function compareWithCallback(a, b, comparer) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
const value = comparer(a, b);
|
|
return value < 0 ? -1 /* LessThan */ : value > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
function createIntlCollatorStringComparer(locale) {
|
|
const comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare;
|
|
return (a, b) => compareWithCallback(a, b, comparer);
|
|
}
|
|
function createLocaleCompareStringComparer(locale) {
|
|
if (locale !== void 0)
|
|
return createFallbackStringComparer();
|
|
return (a, b) => compareWithCallback(a, b, compareStrings);
|
|
function compareStrings(a, b) {
|
|
return a.localeCompare(b);
|
|
}
|
|
}
|
|
function createFallbackStringComparer() {
|
|
return (a, b) => 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 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
}
|
|
function getStringComparerFactory() {
|
|
if (typeof Intl === "object" && typeof Intl.Collator === "function") {
|
|
return createIntlCollatorStringComparer;
|
|
}
|
|
if (typeof String.prototype.localeCompare === "function" && typeof String.prototype.toLocaleUpperCase === "function" && "a".localeCompare("B") < 0) {
|
|
return createLocaleCompareStringComparer;
|
|
}
|
|
return createFallbackStringComparer;
|
|
}
|
|
function createStringComparer(locale) {
|
|
if (locale === void 0) {
|
|
return defaultComparer || (defaultComparer = stringComparerFactory(locale));
|
|
} else if (locale === "en-US") {
|
|
return enUSComparer || (enUSComparer = stringComparerFactory(locale));
|
|
} else {
|
|
return stringComparerFactory(locale);
|
|
}
|
|
}
|
|
})();
|
|
var uiComparerCaseSensitive;
|
|
var uiLocale;
|
|
function setUILocale(value) {
|
|
if (uiLocale !== value) {
|
|
uiLocale = value;
|
|
uiComparerCaseSensitive = void 0;
|
|
}
|
|
}
|
|
function compareBooleans(a, b) {
|
|
return compareValues(a ? 1 : 0, b ? 1 : 0);
|
|
}
|
|
function getSpellingSuggestion(name, candidates, getName) {
|
|
const maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34));
|
|
let bestDistance = Math.floor(name.length * 0.4) + 1;
|
|
let bestCandidate;
|
|
for (const candidate of candidates) {
|
|
const candidateName = getName(candidate);
|
|
if (candidateName !== void 0 && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) {
|
|
if (candidateName === name) {
|
|
continue;
|
|
}
|
|
if (candidateName.length < 3 && candidateName.toLowerCase() !== name.toLowerCase()) {
|
|
continue;
|
|
}
|
|
const distance = levenshteinWithMax(name, candidateName, bestDistance - 0.1);
|
|
if (distance === void 0) {
|
|
continue;
|
|
}
|
|
Debug.assert(distance < bestDistance);
|
|
bestDistance = distance;
|
|
bestCandidate = candidate;
|
|
}
|
|
}
|
|
return bestCandidate;
|
|
}
|
|
function levenshteinWithMax(s1, s2, max) {
|
|
let previous = new Array(s2.length + 1);
|
|
let current = new Array(s2.length + 1);
|
|
const big = max + 0.01;
|
|
for (let i = 0; i <= s2.length; i++) {
|
|
previous[i] = i;
|
|
}
|
|
for (let i = 1; i <= s1.length; i++) {
|
|
const c1 = s1.charCodeAt(i - 1);
|
|
const minJ = Math.ceil(i > max ? i - max : 1);
|
|
const maxJ = Math.floor(s2.length > max + i ? max + i : s2.length);
|
|
current[0] = i;
|
|
let colMin = i;
|
|
for (let j = 1; j < minJ; j++) {
|
|
current[j] = big;
|
|
}
|
|
for (let j = minJ; j <= maxJ; j++) {
|
|
const substitutionDistance = s1[i - 1].toLowerCase() === s2[j - 1].toLowerCase() ? previous[j - 1] + 0.1 : previous[j - 1] + 2;
|
|
const dist = c1 === s2.charCodeAt(j - 1) ? previous[j - 1] : Math.min(previous[j] + 1, current[j - 1] + 1, substitutionDistance);
|
|
current[j] = dist;
|
|
colMin = Math.min(colMin, dist);
|
|
}
|
|
for (let j = maxJ + 1; j <= s2.length; j++) {
|
|
current[j] = big;
|
|
}
|
|
if (colMin > max) {
|
|
return void 0;
|
|
}
|
|
const temp = previous;
|
|
previous = current;
|
|
current = temp;
|
|
}
|
|
const res = previous[s2.length];
|
|
return res > max ? void 0 : res;
|
|
}
|
|
function endsWith(str, suffix) {
|
|
const expectedPos = str.length - suffix.length;
|
|
return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
|
|
}
|
|
function removeSuffix(str, suffix) {
|
|
return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str;
|
|
}
|
|
function stringContains(str, substring) {
|
|
return str.indexOf(substring) !== -1;
|
|
}
|
|
function orderedRemoveItem(array, item) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (array[i] === item) {
|
|
orderedRemoveItemAt(array, i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function orderedRemoveItemAt(array, index) {
|
|
for (let i = index; i < array.length - 1; i++) {
|
|
array[i] = array[i + 1];
|
|
}
|
|
array.pop();
|
|
}
|
|
function unorderedRemoveItemAt(array, index) {
|
|
array[index] = array[array.length - 1];
|
|
array.pop();
|
|
}
|
|
function unorderedRemoveItem(array, item) {
|
|
return unorderedRemoveFirstItemWhere(array, (element) => element === item);
|
|
}
|
|
function unorderedRemoveFirstItemWhere(array, predicate) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (predicate(array[i])) {
|
|
unorderedRemoveItemAt(array, i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createGetCanonicalFileName(useCaseSensitiveFileNames) {
|
|
return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
|
|
}
|
|
function patternText({ prefix, suffix }) {
|
|
return `${prefix}*${suffix}`;
|
|
}
|
|
function matchedText(pattern, candidate) {
|
|
Debug.assert(isPatternMatch(pattern, candidate));
|
|
return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
|
|
}
|
|
function findBestPatternMatch(values, getPattern, candidate) {
|
|
let matchedValue;
|
|
let longestMatchPrefixLength = -1;
|
|
for (const v of values) {
|
|
const pattern = getPattern(v);
|
|
if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
|
|
longestMatchPrefixLength = pattern.prefix.length;
|
|
matchedValue = v;
|
|
}
|
|
}
|
|
return matchedValue;
|
|
}
|
|
function startsWith(str, prefix) {
|
|
return str.lastIndexOf(prefix, 0) === 0;
|
|
}
|
|
function removePrefix(str, prefix) {
|
|
return startsWith(str, prefix) ? str.substr(prefix.length) : str;
|
|
}
|
|
function isPatternMatch({ prefix, suffix }, candidate) {
|
|
return candidate.length >= prefix.length + suffix.length && startsWith(candidate, prefix) && endsWith(candidate, suffix);
|
|
}
|
|
function and(f, g) {
|
|
return (arg) => f(arg) && g(arg);
|
|
}
|
|
function or(...fs) {
|
|
return (...args) => {
|
|
let lastResult;
|
|
for (const f of fs) {
|
|
lastResult = f(...args);
|
|
if (lastResult) {
|
|
return lastResult;
|
|
}
|
|
}
|
|
return lastResult;
|
|
};
|
|
}
|
|
function not(fn) {
|
|
return (...args) => !fn(...args);
|
|
}
|
|
function assertType(_) {
|
|
}
|
|
function singleElementArray(t) {
|
|
return t === void 0 ? void 0 : [t];
|
|
}
|
|
function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) {
|
|
unchanged = unchanged || noop;
|
|
let newIndex = 0;
|
|
let oldIndex = 0;
|
|
const newLen = newItems.length;
|
|
const oldLen = oldItems.length;
|
|
let hasChanges = false;
|
|
while (newIndex < newLen && oldIndex < oldLen) {
|
|
const newItem = newItems[newIndex];
|
|
const oldItem = oldItems[oldIndex];
|
|
const compareResult = comparer(newItem, oldItem);
|
|
if (compareResult === -1 /* LessThan */) {
|
|
inserted(newItem);
|
|
newIndex++;
|
|
hasChanges = true;
|
|
} else if (compareResult === 1 /* 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;
|
|
}
|
|
function cartesianProduct(arrays) {
|
|
const result = [];
|
|
cartesianProductWorker(arrays, result, void 0, 0);
|
|
return result;
|
|
}
|
|
function cartesianProductWorker(arrays, result, outer, index) {
|
|
for (const element of arrays[index]) {
|
|
let inner;
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
function padLeft(s, length2, padString = " ") {
|
|
return length2 <= s.length ? s : padString.repeat(length2 - s.length) + s;
|
|
}
|
|
function padRight(s, length2, padString = " ") {
|
|
return length2 <= s.length ? s : s + padString.repeat(length2 - s.length);
|
|
}
|
|
function takeWhile(array, predicate) {
|
|
const len = array.length;
|
|
let index = 0;
|
|
while (index < len && predicate(array[index])) {
|
|
index++;
|
|
}
|
|
return array.slice(0, index);
|
|
}
|
|
var trimString = !!String.prototype.trim ? (s) => s.trim() : (s) => trimStringEnd(trimStringStart(s));
|
|
var trimStringEnd = !!String.prototype.trimEnd ? (s) => s.trimEnd() : trimEndImpl;
|
|
var trimStringStart = !!String.prototype.trimStart ? (s) => s.trimStart() : (s) => s.replace(/^\s+/g, "");
|
|
function trimEndImpl(s) {
|
|
let end = s.length - 1;
|
|
while (end >= 0) {
|
|
if (!isWhiteSpaceLike(s.charCodeAt(end)))
|
|
break;
|
|
end--;
|
|
}
|
|
return s.slice(0, end + 1);
|
|
}
|
|
function isNodeLikeSystem() {
|
|
return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
|
|
}
|
|
|
|
// src/compiler/debug.ts
|
|
var Debug;
|
|
((Debug2) => {
|
|
let currentAssertionLevel = 0 /* None */;
|
|
Debug2.currentLogLevel = 2 /* Warning */;
|
|
Debug2.isDebugging = false;
|
|
function shouldLog(level) {
|
|
return Debug2.currentLogLevel <= level;
|
|
}
|
|
Debug2.shouldLog = shouldLog;
|
|
function logMessage(level, s) {
|
|
if (Debug2.loggingHost && shouldLog(level)) {
|
|
Debug2.loggingHost.log(level, s);
|
|
}
|
|
}
|
|
function log(s) {
|
|
logMessage(3 /* Info */, s);
|
|
}
|
|
Debug2.log = log;
|
|
((_log) => {
|
|
function error(s) {
|
|
logMessage(1 /* Error */, s);
|
|
}
|
|
_log.error = error;
|
|
function warn(s) {
|
|
logMessage(2 /* Warning */, s);
|
|
}
|
|
_log.warn = warn;
|
|
function log2(s) {
|
|
logMessage(3 /* Info */, s);
|
|
}
|
|
_log.log = log2;
|
|
function trace2(s) {
|
|
logMessage(4 /* Verbose */, s);
|
|
}
|
|
_log.trace = trace2;
|
|
})(log = Debug2.log || (Debug2.log = {}));
|
|
const assertionCache = {};
|
|
function getAssertionLevel() {
|
|
return currentAssertionLevel;
|
|
}
|
|
Debug2.getAssertionLevel = getAssertionLevel;
|
|
function setAssertionLevel(level) {
|
|
const prevAssertionLevel = currentAssertionLevel;
|
|
currentAssertionLevel = level;
|
|
if (level > prevAssertionLevel) {
|
|
for (const key of getOwnKeys(assertionCache)) {
|
|
const cachedFunc = assertionCache[key];
|
|
if (cachedFunc !== void 0 && Debug2[key] !== cachedFunc.assertion && level >= cachedFunc.level) {
|
|
Debug2[key] = cachedFunc;
|
|
assertionCache[key] = void 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Debug2.setAssertionLevel = setAssertionLevel;
|
|
function shouldAssert(level) {
|
|
return currentAssertionLevel >= level;
|
|
}
|
|
Debug2.shouldAssert = shouldAssert;
|
|
function shouldAssertFunction(level, name) {
|
|
if (!shouldAssert(level)) {
|
|
assertionCache[name] = { level, assertion: Debug2[name] };
|
|
Debug2[name] = noop;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function fail(message, stackCrawlMark) {
|
|
debugger;
|
|
const e = new Error(message ? `Debug Failure. ${message}` : "Debug Failure.");
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(e, stackCrawlMark || fail);
|
|
}
|
|
throw e;
|
|
}
|
|
Debug2.fail = fail;
|
|
function failBadSyntaxKind(node, message, stackCrawlMark) {
|
|
return fail(
|
|
`${message || "Unexpected node."}\r
|
|
Node ${formatSyntaxKind(node.kind)} was unexpected.`,
|
|
stackCrawlMark || failBadSyntaxKind
|
|
);
|
|
}
|
|
Debug2.failBadSyntaxKind = failBadSyntaxKind;
|
|
function assert(expression, message, verboseDebugInfo, stackCrawlMark) {
|
|
if (!expression) {
|
|
message = message ? `False expression: ${message}` : "False expression.";
|
|
if (verboseDebugInfo) {
|
|
message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
|
|
}
|
|
fail(message, stackCrawlMark || assert);
|
|
}
|
|
}
|
|
Debug2.assert = assert;
|
|
function assertEqual(a, b, msg, msg2, stackCrawlMark) {
|
|
if (a !== b) {
|
|
const message = msg ? msg2 ? `${msg} ${msg2}` : msg : "";
|
|
fail(`Expected ${a} === ${b}. ${message}`, stackCrawlMark || assertEqual);
|
|
}
|
|
}
|
|
Debug2.assertEqual = assertEqual;
|
|
function assertLessThan(a, b, msg, stackCrawlMark) {
|
|
if (a >= b) {
|
|
fail(`Expected ${a} < ${b}. ${msg || ""}`, stackCrawlMark || assertLessThan);
|
|
}
|
|
}
|
|
Debug2.assertLessThan = assertLessThan;
|
|
function assertLessThanOrEqual(a, b, stackCrawlMark) {
|
|
if (a > b) {
|
|
fail(`Expected ${a} <= ${b}`, stackCrawlMark || assertLessThanOrEqual);
|
|
}
|
|
}
|
|
Debug2.assertLessThanOrEqual = assertLessThanOrEqual;
|
|
function assertGreaterThanOrEqual(a, b, stackCrawlMark) {
|
|
if (a < b) {
|
|
fail(`Expected ${a} >= ${b}`, stackCrawlMark || assertGreaterThanOrEqual);
|
|
}
|
|
}
|
|
Debug2.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
|
|
function assertIsDefined(value, message, stackCrawlMark) {
|
|
if (value === void 0 || value === null) {
|
|
fail(message, stackCrawlMark || assertIsDefined);
|
|
}
|
|
}
|
|
Debug2.assertIsDefined = assertIsDefined;
|
|
function checkDefined(value, message, stackCrawlMark) {
|
|
assertIsDefined(value, message, stackCrawlMark || checkDefined);
|
|
return value;
|
|
}
|
|
Debug2.checkDefined = checkDefined;
|
|
function assertEachIsDefined(value, message, stackCrawlMark) {
|
|
for (const v of value) {
|
|
assertIsDefined(v, message, stackCrawlMark || assertEachIsDefined);
|
|
}
|
|
}
|
|
Debug2.assertEachIsDefined = assertEachIsDefined;
|
|
function checkEachDefined(value, message, stackCrawlMark) {
|
|
assertEachIsDefined(value, message, stackCrawlMark || checkEachDefined);
|
|
return value;
|
|
}
|
|
Debug2.checkEachDefined = checkEachDefined;
|
|
function assertNever(member, message = "Illegal value:", stackCrawlMark) {
|
|
const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
|
|
return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
|
|
}
|
|
Debug2.assertNever = assertNever;
|
|
function assertEachNode(nodes, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertEachNode")) {
|
|
assert(
|
|
test === void 0 || every(nodes, test),
|
|
message || "Unexpected node.",
|
|
() => `Node array did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertEachNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertEachNode = assertEachNode;
|
|
function assertNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertNode")) {
|
|
assert(
|
|
node !== void 0 && (test === void 0 || test(node)),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertNode = assertNode;
|
|
function assertNotNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertNotNode")) {
|
|
assert(
|
|
node === void 0 || test === void 0 || !test(node),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node.kind)} should not have passed test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertNotNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertNotNode = assertNotNode;
|
|
function assertOptionalNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertOptionalNode")) {
|
|
assert(
|
|
test === void 0 || node === void 0 || test(node),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertOptionalNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertOptionalNode = assertOptionalNode;
|
|
function assertOptionalToken(node, kind, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertOptionalToken")) {
|
|
assert(
|
|
kind === void 0 || node === void 0 || node.kind === kind,
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} was not a '${formatSyntaxKind(kind)}' token.`,
|
|
stackCrawlMark || assertOptionalToken
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertOptionalToken = assertOptionalToken;
|
|
function assertMissingNode(node, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertMissingNode")) {
|
|
assert(
|
|
node === void 0,
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node.kind)} was unexpected'.`,
|
|
stackCrawlMark || assertMissingNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertMissingNode = assertMissingNode;
|
|
function type(_value) {
|
|
}
|
|
Debug2.type = type;
|
|
function getFunctionName(func) {
|
|
if (typeof func !== "function") {
|
|
return "";
|
|
} else if (hasProperty(func, "name")) {
|
|
return func.name;
|
|
} else {
|
|
const text = Function.prototype.toString.call(func);
|
|
const match = /^function\s+([\w\$]+)\s*\(/.exec(text);
|
|
return match ? match[1] : "";
|
|
}
|
|
}
|
|
Debug2.getFunctionName = getFunctionName;
|
|
function formatSymbol(symbol) {
|
|
return `{ name: ${unescapeLeadingUnderscores(symbol.escapedName)}; flags: ${formatSymbolFlags(symbol.flags)}; declarations: ${map(symbol.declarations, (node) => formatSyntaxKind(node.kind))} }`;
|
|
}
|
|
Debug2.formatSymbol = formatSymbol;
|
|
function formatEnum(value = 0, enumObject, isFlags) {
|
|
const members = getEnumMembers(enumObject);
|
|
if (value === 0) {
|
|
return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0";
|
|
}
|
|
if (isFlags) {
|
|
const result = [];
|
|
let remainingFlags = value;
|
|
for (const [enumValue, enumName] of members) {
|
|
if (enumValue > value) {
|
|
break;
|
|
}
|
|
if (enumValue !== 0 && enumValue & value) {
|
|
result.push(enumName);
|
|
remainingFlags &= ~enumValue;
|
|
}
|
|
}
|
|
if (remainingFlags === 0) {
|
|
return result.join("|");
|
|
}
|
|
} else {
|
|
for (const [enumValue, enumName] of members) {
|
|
if (enumValue === value) {
|
|
return enumName;
|
|
}
|
|
}
|
|
}
|
|
return value.toString();
|
|
}
|
|
Debug2.formatEnum = formatEnum;
|
|
const enumMemberCache = /* @__PURE__ */ new Map();
|
|
function getEnumMembers(enumObject) {
|
|
const existing = enumMemberCache.get(enumObject);
|
|
if (existing) {
|
|
return existing;
|
|
}
|
|
const result = [];
|
|
for (const name in enumObject) {
|
|
const value = enumObject[name];
|
|
if (typeof value === "number") {
|
|
result.push([value, name]);
|
|
}
|
|
}
|
|
const sorted = stableSort(result, (x, y) => compareValues(x[0], y[0]));
|
|
enumMemberCache.set(enumObject, sorted);
|
|
return sorted;
|
|
}
|
|
function formatSyntaxKind(kind) {
|
|
return formatEnum(kind, SyntaxKind, false);
|
|
}
|
|
Debug2.formatSyntaxKind = formatSyntaxKind;
|
|
function formatSnippetKind(kind) {
|
|
return formatEnum(kind, SnippetKind, false);
|
|
}
|
|
Debug2.formatSnippetKind = formatSnippetKind;
|
|
function formatNodeFlags(flags) {
|
|
return formatEnum(flags, NodeFlags, true);
|
|
}
|
|
Debug2.formatNodeFlags = formatNodeFlags;
|
|
function formatModifierFlags(flags) {
|
|
return formatEnum(flags, ModifierFlags, true);
|
|
}
|
|
Debug2.formatModifierFlags = formatModifierFlags;
|
|
function formatTransformFlags(flags) {
|
|
return formatEnum(flags, TransformFlags, true);
|
|
}
|
|
Debug2.formatTransformFlags = formatTransformFlags;
|
|
function formatEmitFlags(flags) {
|
|
return formatEnum(flags, EmitFlags, true);
|
|
}
|
|
Debug2.formatEmitFlags = formatEmitFlags;
|
|
function formatSymbolFlags(flags) {
|
|
return formatEnum(flags, SymbolFlags, true);
|
|
}
|
|
Debug2.formatSymbolFlags = formatSymbolFlags;
|
|
function formatTypeFlags(flags) {
|
|
return formatEnum(flags, TypeFlags, true);
|
|
}
|
|
Debug2.formatTypeFlags = formatTypeFlags;
|
|
function formatSignatureFlags(flags) {
|
|
return formatEnum(flags, SignatureFlags, true);
|
|
}
|
|
Debug2.formatSignatureFlags = formatSignatureFlags;
|
|
function formatObjectFlags(flags) {
|
|
return formatEnum(flags, ObjectFlags, true);
|
|
}
|
|
Debug2.formatObjectFlags = formatObjectFlags;
|
|
function formatFlowFlags(flags) {
|
|
return formatEnum(flags, FlowFlags, true);
|
|
}
|
|
Debug2.formatFlowFlags = formatFlowFlags;
|
|
function formatRelationComparisonResult(result) {
|
|
return formatEnum(result, RelationComparisonResult, true);
|
|
}
|
|
Debug2.formatRelationComparisonResult = formatRelationComparisonResult;
|
|
function formatCheckMode(mode) {
|
|
return formatEnum(mode, CheckMode, true);
|
|
}
|
|
Debug2.formatCheckMode = formatCheckMode;
|
|
function formatSignatureCheckMode(mode) {
|
|
return formatEnum(mode, SignatureCheckMode, true);
|
|
}
|
|
Debug2.formatSignatureCheckMode = formatSignatureCheckMode;
|
|
function formatTypeFacts(facts) {
|
|
return formatEnum(facts, TypeFacts, true);
|
|
}
|
|
Debug2.formatTypeFacts = formatTypeFacts;
|
|
let isDebugInfoEnabled = false;
|
|
let flowNodeProto;
|
|
function attachFlowNodeDebugInfoWorker(flowNode) {
|
|
if (!("__debugFlowFlags" in flowNode)) {
|
|
Object.defineProperties(flowNode, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const flowHeader = this.flags & 2 /* Start */ ? "FlowStart" : this.flags & 4 /* BranchLabel */ ? "FlowBranchLabel" : this.flags & 8 /* LoopLabel */ ? "FlowLoopLabel" : this.flags & 16 /* Assignment */ ? "FlowAssignment" : this.flags & 32 /* TrueCondition */ ? "FlowTrueCondition" : this.flags & 64 /* FalseCondition */ ? "FlowFalseCondition" : this.flags & 128 /* SwitchClause */ ? "FlowSwitchClause" : this.flags & 256 /* ArrayMutation */ ? "FlowArrayMutation" : this.flags & 512 /* Call */ ? "FlowCall" : this.flags & 1024 /* ReduceLabel */ ? "FlowReduceLabel" : this.flags & 1 /* Unreachable */ ? "FlowUnreachable" : "UnknownFlow";
|
|
const remainingFlags = this.flags & ~(2048 /* Referenced */ - 1);
|
|
return `${flowHeader}${remainingFlags ? ` (${formatFlowFlags(remainingFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlowFlags: { get() {
|
|
return formatEnum(this.flags, FlowFlags, true);
|
|
} },
|
|
__debugToString: { value() {
|
|
return formatControlFlowGraph(this);
|
|
} }
|
|
});
|
|
}
|
|
}
|
|
function attachFlowNodeDebugInfo(flowNode) {
|
|
if (isDebugInfoEnabled) {
|
|
if (typeof Object.setPrototypeOf === "function") {
|
|
if (!flowNodeProto) {
|
|
flowNodeProto = Object.create(Object.prototype);
|
|
attachFlowNodeDebugInfoWorker(flowNodeProto);
|
|
}
|
|
Object.setPrototypeOf(flowNode, flowNodeProto);
|
|
} else {
|
|
attachFlowNodeDebugInfoWorker(flowNode);
|
|
}
|
|
}
|
|
}
|
|
Debug2.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
|
|
let nodeArrayProto;
|
|
function attachNodeArrayDebugInfoWorker(array) {
|
|
if (!("__tsDebuggerDisplay" in array)) {
|
|
Object.defineProperties(array, {
|
|
__tsDebuggerDisplay: {
|
|
value(defaultValue) {
|
|
defaultValue = String(defaultValue).replace(/(?:,[\s\w\d_]+:[^,]+)+\]$/, "]");
|
|
return `NodeArray ${defaultValue}`;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function attachNodeArrayDebugInfo(array) {
|
|
if (isDebugInfoEnabled) {
|
|
if (typeof Object.setPrototypeOf === "function") {
|
|
if (!nodeArrayProto) {
|
|
nodeArrayProto = Object.create(Array.prototype);
|
|
attachNodeArrayDebugInfoWorker(nodeArrayProto);
|
|
}
|
|
Object.setPrototypeOf(array, nodeArrayProto);
|
|
} else {
|
|
attachNodeArrayDebugInfoWorker(array);
|
|
}
|
|
}
|
|
}
|
|
Debug2.attachNodeArrayDebugInfo = attachNodeArrayDebugInfo;
|
|
function enableDebugInfo() {
|
|
if (isDebugInfoEnabled)
|
|
return;
|
|
let weakTypeTextMap;
|
|
let weakNodeTextMap;
|
|
function getWeakTypeTextMap() {
|
|
if (weakTypeTextMap === void 0) {
|
|
if (typeof WeakMap === "function")
|
|
weakTypeTextMap = /* @__PURE__ */ new WeakMap();
|
|
}
|
|
return weakTypeTextMap;
|
|
}
|
|
function getWeakNodeTextMap() {
|
|
if (weakNodeTextMap === void 0) {
|
|
if (typeof WeakMap === "function")
|
|
weakNodeTextMap = /* @__PURE__ */ new WeakMap();
|
|
}
|
|
return weakNodeTextMap;
|
|
}
|
|
Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const symbolHeader = this.flags & 33554432 /* Transient */ ? "TransientSymbol" : "Symbol";
|
|
const remainingSymbolFlags = this.flags & ~33554432 /* Transient */;
|
|
return `${symbolHeader} '${symbolName(this)}'${remainingSymbolFlags ? ` (${formatSymbolFlags(remainingSymbolFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlags: { get() {
|
|
return formatSymbolFlags(this.flags);
|
|
} }
|
|
});
|
|
Object.defineProperties(objectAllocator.getTypeConstructor().prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const typeHeader = this.flags & 98304 /* Nullable */ ? "NullableType" : this.flags & 384 /* StringOrNumberLiteral */ ? `LiteralType ${JSON.stringify(this.value)}` : this.flags & 2048 /* BigIntLiteral */ ? `LiteralType ${this.value.negative ? "-" : ""}${this.value.base10Value}n` : this.flags & 8192 /* UniqueESSymbol */ ? "UniqueESSymbolType" : this.flags & 32 /* Enum */ ? "EnumType" : this.flags & 67359327 /* Intrinsic */ ? `IntrinsicType ${this.intrinsicName}` : this.flags & 1048576 /* Union */ ? "UnionType" : this.flags & 2097152 /* Intersection */ ? "IntersectionType" : this.flags & 4194304 /* Index */ ? "IndexType" : this.flags & 8388608 /* IndexedAccess */ ? "IndexedAccessType" : this.flags & 16777216 /* Conditional */ ? "ConditionalType" : this.flags & 33554432 /* Substitution */ ? "SubstitutionType" : this.flags & 262144 /* TypeParameter */ ? "TypeParameter" : this.flags & 524288 /* Object */ ? this.objectFlags & 3 /* ClassOrInterface */ ? "InterfaceType" : this.objectFlags & 4 /* Reference */ ? "TypeReference" : this.objectFlags & 8 /* Tuple */ ? "TupleType" : this.objectFlags & 16 /* Anonymous */ ? "AnonymousType" : this.objectFlags & 32 /* Mapped */ ? "MappedType" : this.objectFlags & 1024 /* ReverseMapped */ ? "ReverseMappedType" : this.objectFlags & 256 /* EvolvingArray */ ? "EvolvingArrayType" : "ObjectType" : "Type";
|
|
const remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~1343 /* ObjectTypeKindMask */ : 0;
|
|
return `${typeHeader}${this.symbol ? ` '${symbolName(this.symbol)}'` : ""}${remainingObjectFlags ? ` (${formatObjectFlags(remainingObjectFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlags: { get() {
|
|
return formatTypeFlags(this.flags);
|
|
} },
|
|
__debugObjectFlags: { get() {
|
|
return this.flags & 524288 /* Object */ ? formatObjectFlags(this.objectFlags) : "";
|
|
} },
|
|
__debugTypeToString: {
|
|
value() {
|
|
const map2 = getWeakTypeTextMap();
|
|
let text = map2 == null ? void 0 : map2.get(this);
|
|
if (text === void 0) {
|
|
text = this.checker.typeToString(this);
|
|
map2 == null ? void 0 : map2.set(this, text);
|
|
}
|
|
return text;
|
|
}
|
|
}
|
|
});
|
|
Object.defineProperties(objectAllocator.getSignatureConstructor().prototype, {
|
|
__debugFlags: { get() {
|
|
return formatSignatureFlags(this.flags);
|
|
} },
|
|
__debugSignatureToString: { value() {
|
|
var _a2;
|
|
return (_a2 = this.checker) == null ? void 0 : _a2.signatureToString(this);
|
|
} }
|
|
});
|
|
const nodeConstructors = [
|
|
objectAllocator.getNodeConstructor(),
|
|
objectAllocator.getIdentifierConstructor(),
|
|
objectAllocator.getTokenConstructor(),
|
|
objectAllocator.getSourceFileConstructor()
|
|
];
|
|
for (const ctor of nodeConstructors) {
|
|
if (!hasProperty(ctor.prototype, "__debugKind")) {
|
|
Object.defineProperties(ctor.prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const nodeHeader = isGeneratedIdentifier(this) ? "GeneratedIdentifier" : isIdentifier(this) ? `Identifier '${idText(this)}'` : isPrivateIdentifier(this) ? `PrivateIdentifier '${idText(this)}'` : isStringLiteral(this) ? `StringLiteral ${JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...")}` : isNumericLiteral(this) ? `NumericLiteral ${this.text}` : isBigIntLiteral(this) ? `BigIntLiteral ${this.text}n` : isTypeParameterDeclaration(this) ? "TypeParameterDeclaration" : isParameter(this) ? "ParameterDeclaration" : isConstructorDeclaration(this) ? "ConstructorDeclaration" : isGetAccessorDeclaration(this) ? "GetAccessorDeclaration" : isSetAccessorDeclaration(this) ? "SetAccessorDeclaration" : isCallSignatureDeclaration(this) ? "CallSignatureDeclaration" : isConstructSignatureDeclaration(this) ? "ConstructSignatureDeclaration" : isIndexSignatureDeclaration(this) ? "IndexSignatureDeclaration" : isTypePredicateNode(this) ? "TypePredicateNode" : isTypeReferenceNode(this) ? "TypeReferenceNode" : isFunctionTypeNode(this) ? "FunctionTypeNode" : isConstructorTypeNode(this) ? "ConstructorTypeNode" : isTypeQueryNode(this) ? "TypeQueryNode" : isTypeLiteralNode(this) ? "TypeLiteralNode" : isArrayTypeNode(this) ? "ArrayTypeNode" : isTupleTypeNode(this) ? "TupleTypeNode" : isOptionalTypeNode(this) ? "OptionalTypeNode" : isRestTypeNode(this) ? "RestTypeNode" : isUnionTypeNode(this) ? "UnionTypeNode" : isIntersectionTypeNode(this) ? "IntersectionTypeNode" : isConditionalTypeNode(this) ? "ConditionalTypeNode" : isInferTypeNode(this) ? "InferTypeNode" : isParenthesizedTypeNode(this) ? "ParenthesizedTypeNode" : isThisTypeNode(this) ? "ThisTypeNode" : isTypeOperatorNode(this) ? "TypeOperatorNode" : isIndexedAccessTypeNode(this) ? "IndexedAccessTypeNode" : isMappedTypeNode(this) ? "MappedTypeNode" : isLiteralTypeNode(this) ? "LiteralTypeNode" : isNamedTupleMember(this) ? "NamedTupleMember" : isImportTypeNode(this) ? "ImportTypeNode" : formatSyntaxKind(this.kind);
|
|
return `${nodeHeader}${this.flags ? ` (${formatNodeFlags(this.flags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugKind: { get() {
|
|
return formatSyntaxKind(this.kind);
|
|
} },
|
|
__debugNodeFlags: { get() {
|
|
return formatNodeFlags(this.flags);
|
|
} },
|
|
__debugModifierFlags: { get() {
|
|
return formatModifierFlags(getEffectiveModifierFlagsNoCache(this));
|
|
} },
|
|
__debugTransformFlags: { get() {
|
|
return formatTransformFlags(this.transformFlags);
|
|
} },
|
|
__debugIsParseTreeNode: { get() {
|
|
return isParseTreeNode(this);
|
|
} },
|
|
__debugEmitFlags: { get() {
|
|
return formatEmitFlags(getEmitFlags(this));
|
|
} },
|
|
__debugGetText: {
|
|
value(includeTrivia) {
|
|
if (nodeIsSynthesized(this))
|
|
return "";
|
|
const map2 = getWeakNodeTextMap();
|
|
let text = map2 == null ? void 0 : map2.get(this);
|
|
if (text === void 0) {
|
|
const parseNode = getParseTreeNode(this);
|
|
const sourceFile = parseNode && getSourceFileOfNode(parseNode);
|
|
text = sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
|
|
map2 == null ? void 0 : map2.set(this, text);
|
|
}
|
|
return text;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
isDebugInfoEnabled = true;
|
|
}
|
|
Debug2.enableDebugInfo = enableDebugInfo;
|
|
function formatVariance(varianceFlags) {
|
|
const variance = varianceFlags & 7 /* VarianceMask */;
|
|
let result = variance === 0 /* Invariant */ ? "in out" : variance === 3 /* Bivariant */ ? "[bivariant]" : variance === 2 /* Contravariant */ ? "in" : variance === 1 /* Covariant */ ? "out" : variance === 4 /* Independent */ ? "[independent]" : "";
|
|
if (varianceFlags & 8 /* Unmeasurable */) {
|
|
result += " (unmeasurable)";
|
|
} else if (varianceFlags & 16 /* Unreliable */) {
|
|
result += " (unreliable)";
|
|
}
|
|
return result;
|
|
}
|
|
Debug2.formatVariance = formatVariance;
|
|
class DebugTypeMapper {
|
|
__debugToString() {
|
|
var _a2;
|
|
type(this);
|
|
switch (this.kind) {
|
|
case 3 /* Function */:
|
|
return ((_a2 = this.debugInfo) == null ? void 0 : _a2.call(this)) || "(function mapper)";
|
|
case 0 /* Simple */:
|
|
return `${this.source.__debugTypeToString()} -> ${this.target.__debugTypeToString()}`;
|
|
case 1 /* Array */:
|
|
return zipWith(
|
|
this.sources,
|
|
this.targets || map(this.sources, () => "any"),
|
|
(s, t) => `${s.__debugTypeToString()} -> ${typeof t === "string" ? t : t.__debugTypeToString()}`
|
|
).join(", ");
|
|
case 2 /* Deferred */:
|
|
return zipWith(
|
|
this.sources,
|
|
this.targets,
|
|
(s, t) => `${s.__debugTypeToString()} -> ${t().__debugTypeToString()}`
|
|
).join(", ");
|
|
case 5 /* Merged */:
|
|
case 4 /* Composite */:
|
|
return `m1: ${this.mapper1.__debugToString().split("\n").join("\n ")}
|
|
m2: ${this.mapper2.__debugToString().split("\n").join("\n ")}`;
|
|
default:
|
|
return assertNever(this);
|
|
}
|
|
}
|
|
}
|
|
Debug2.DebugTypeMapper = DebugTypeMapper;
|
|
function attachDebugPrototypeIfDebug(mapper) {
|
|
if (Debug2.isDebugging) {
|
|
return Object.setPrototypeOf(mapper, DebugTypeMapper.prototype);
|
|
}
|
|
return mapper;
|
|
}
|
|
Debug2.attachDebugPrototypeIfDebug = attachDebugPrototypeIfDebug;
|
|
function printControlFlowGraph(flowNode) {
|
|
return console.log(formatControlFlowGraph(flowNode));
|
|
}
|
|
Debug2.printControlFlowGraph = printControlFlowGraph;
|
|
function formatControlFlowGraph(flowNode) {
|
|
let nextDebugFlowId = -1;
|
|
function getDebugFlowNodeId(f) {
|
|
if (!f.id) {
|
|
f.id = nextDebugFlowId;
|
|
nextDebugFlowId--;
|
|
}
|
|
return f.id;
|
|
}
|
|
let BoxCharacter;
|
|
((BoxCharacter2) => {
|
|
BoxCharacter2["lr"] = "\u2500";
|
|
BoxCharacter2["ud"] = "\u2502";
|
|
BoxCharacter2["dr"] = "\u256D";
|
|
BoxCharacter2["dl"] = "\u256E";
|
|
BoxCharacter2["ul"] = "\u256F";
|
|
BoxCharacter2["ur"] = "\u2570";
|
|
BoxCharacter2["udr"] = "\u251C";
|
|
BoxCharacter2["udl"] = "\u2524";
|
|
BoxCharacter2["dlr"] = "\u252C";
|
|
BoxCharacter2["ulr"] = "\u2534";
|
|
BoxCharacter2["udlr"] = "\u256B";
|
|
})(BoxCharacter || (BoxCharacter = {}));
|
|
let Connection;
|
|
((Connection2) => {
|
|
Connection2[Connection2["None"] = 0] = "None";
|
|
Connection2[Connection2["Up"] = 1] = "Up";
|
|
Connection2[Connection2["Down"] = 2] = "Down";
|
|
Connection2[Connection2["Left"] = 4] = "Left";
|
|
Connection2[Connection2["Right"] = 8] = "Right";
|
|
Connection2[Connection2["UpDown"] = 3] = "UpDown";
|
|
Connection2[Connection2["LeftRight"] = 12] = "LeftRight";
|
|
Connection2[Connection2["UpLeft"] = 5] = "UpLeft";
|
|
Connection2[Connection2["UpRight"] = 9] = "UpRight";
|
|
Connection2[Connection2["DownLeft"] = 6] = "DownLeft";
|
|
Connection2[Connection2["DownRight"] = 10] = "DownRight";
|
|
Connection2[Connection2["UpDownLeft"] = 7] = "UpDownLeft";
|
|
Connection2[Connection2["UpDownRight"] = 11] = "UpDownRight";
|
|
Connection2[Connection2["UpLeftRight"] = 13] = "UpLeftRight";
|
|
Connection2[Connection2["DownLeftRight"] = 14] = "DownLeftRight";
|
|
Connection2[Connection2["UpDownLeftRight"] = 15] = "UpDownLeftRight";
|
|
Connection2[Connection2["NoChildren"] = 16] = "NoChildren";
|
|
})(Connection || (Connection = {}));
|
|
const hasAntecedentFlags = 16 /* Assignment */ | 96 /* Condition */ | 128 /* SwitchClause */ | 256 /* ArrayMutation */ | 512 /* Call */ | 1024 /* ReduceLabel */;
|
|
const hasNodeFlags = 2 /* Start */ | 16 /* Assignment */ | 512 /* Call */ | 96 /* Condition */ | 256 /* ArrayMutation */;
|
|
const links = /* @__PURE__ */ Object.create(null);
|
|
const nodes = [];
|
|
const edges = [];
|
|
const root = buildGraphNode(flowNode, /* @__PURE__ */ new Set());
|
|
for (const node of nodes) {
|
|
node.text = renderFlowNode(node.flowNode, node.circular);
|
|
computeLevel(node);
|
|
}
|
|
const height = computeHeight(root);
|
|
const columnWidths = computeColumnWidths(height);
|
|
computeLanes(root, 0);
|
|
return renderGraph();
|
|
function isFlowSwitchClause(f) {
|
|
return !!(f.flags & 128 /* SwitchClause */);
|
|
}
|
|
function hasAntecedents(f) {
|
|
return !!(f.flags & 12 /* Label */) && !!f.antecedents;
|
|
}
|
|
function hasAntecedent(f) {
|
|
return !!(f.flags & hasAntecedentFlags);
|
|
}
|
|
function hasNode(f) {
|
|
return !!(f.flags & hasNodeFlags);
|
|
}
|
|
function getChildren(node) {
|
|
const children = [];
|
|
for (const edge of node.edges) {
|
|
if (edge.source === node) {
|
|
children.push(edge.target);
|
|
}
|
|
}
|
|
return children;
|
|
}
|
|
function getParents(node) {
|
|
const parents = [];
|
|
for (const edge of node.edges) {
|
|
if (edge.target === node) {
|
|
parents.push(edge.source);
|
|
}
|
|
}
|
|
return parents;
|
|
}
|
|
function buildGraphNode(flowNode2, seen) {
|
|
const id = getDebugFlowNodeId(flowNode2);
|
|
let graphNode = links[id];
|
|
if (graphNode && seen.has(flowNode2)) {
|
|
graphNode.circular = true;
|
|
graphNode = {
|
|
id: -1,
|
|
flowNode: flowNode2,
|
|
edges: [],
|
|
text: "",
|
|
lane: -1,
|
|
endLane: -1,
|
|
level: -1,
|
|
circular: "circularity"
|
|
};
|
|
nodes.push(graphNode);
|
|
return graphNode;
|
|
}
|
|
seen.add(flowNode2);
|
|
if (!graphNode) {
|
|
links[id] = graphNode = { id, flowNode: flowNode2, edges: [], text: "", lane: -1, endLane: -1, level: -1, circular: false };
|
|
nodes.push(graphNode);
|
|
if (hasAntecedents(flowNode2)) {
|
|
for (const antecedent of flowNode2.antecedents) {
|
|
buildGraphEdge(graphNode, antecedent, seen);
|
|
}
|
|
} else if (hasAntecedent(flowNode2)) {
|
|
buildGraphEdge(graphNode, flowNode2.antecedent, seen);
|
|
}
|
|
}
|
|
seen.delete(flowNode2);
|
|
return graphNode;
|
|
}
|
|
function buildGraphEdge(source, antecedent, seen) {
|
|
const target = buildGraphNode(antecedent, seen);
|
|
const edge = { source, target };
|
|
edges.push(edge);
|
|
source.edges.push(edge);
|
|
target.edges.push(edge);
|
|
}
|
|
function computeLevel(node) {
|
|
if (node.level !== -1) {
|
|
return node.level;
|
|
}
|
|
let level = 0;
|
|
for (const parent of getParents(node)) {
|
|
level = Math.max(level, computeLevel(parent) + 1);
|
|
}
|
|
return node.level = level;
|
|
}
|
|
function computeHeight(node) {
|
|
let height2 = 0;
|
|
for (const child of getChildren(node)) {
|
|
height2 = Math.max(height2, computeHeight(child));
|
|
}
|
|
return height2 + 1;
|
|
}
|
|
function computeColumnWidths(height2) {
|
|
const columns = fill(Array(height2), 0);
|
|
for (const node of nodes) {
|
|
columns[node.level] = Math.max(columns[node.level], node.text.length);
|
|
}
|
|
return columns;
|
|
}
|
|
function computeLanes(node, lane) {
|
|
if (node.lane === -1) {
|
|
node.lane = lane;
|
|
node.endLane = lane;
|
|
const children = getChildren(node);
|
|
for (let i = 0; i < children.length; i++) {
|
|
if (i > 0)
|
|
lane++;
|
|
const child = children[i];
|
|
computeLanes(child, lane);
|
|
if (child.endLane > node.endLane) {
|
|
lane = child.endLane;
|
|
}
|
|
}
|
|
node.endLane = lane;
|
|
}
|
|
}
|
|
function getHeader2(flags) {
|
|
if (flags & 2 /* Start */)
|
|
return "Start";
|
|
if (flags & 4 /* BranchLabel */)
|
|
return "Branch";
|
|
if (flags & 8 /* LoopLabel */)
|
|
return "Loop";
|
|
if (flags & 16 /* Assignment */)
|
|
return "Assignment";
|
|
if (flags & 32 /* TrueCondition */)
|
|
return "True";
|
|
if (flags & 64 /* FalseCondition */)
|
|
return "False";
|
|
if (flags & 128 /* SwitchClause */)
|
|
return "SwitchClause";
|
|
if (flags & 256 /* ArrayMutation */)
|
|
return "ArrayMutation";
|
|
if (flags & 512 /* Call */)
|
|
return "Call";
|
|
if (flags & 1024 /* ReduceLabel */)
|
|
return "ReduceLabel";
|
|
if (flags & 1 /* Unreachable */)
|
|
return "Unreachable";
|
|
throw new Error();
|
|
}
|
|
function getNodeText(node) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node, false);
|
|
}
|
|
function renderFlowNode(flowNode2, circular) {
|
|
let text = getHeader2(flowNode2.flags);
|
|
if (circular) {
|
|
text = `${text}#${getDebugFlowNodeId(flowNode2)}`;
|
|
}
|
|
if (hasNode(flowNode2)) {
|
|
if (flowNode2.node) {
|
|
text += ` (${getNodeText(flowNode2.node)})`;
|
|
}
|
|
} else if (isFlowSwitchClause(flowNode2)) {
|
|
const clauses = [];
|
|
for (let i = flowNode2.clauseStart; i < flowNode2.clauseEnd; i++) {
|
|
const clause = flowNode2.switchStatement.caseBlock.clauses[i];
|
|
if (isDefaultClause(clause)) {
|
|
clauses.push("default");
|
|
} else {
|
|
clauses.push(getNodeText(clause.expression));
|
|
}
|
|
}
|
|
text += ` (${clauses.join(", ")})`;
|
|
}
|
|
return circular === "circularity" ? `Circular(${text})` : text;
|
|
}
|
|
function renderGraph() {
|
|
const columnCount = columnWidths.length;
|
|
const laneCount = nodes.reduce((x, n) => Math.max(x, n.lane), 0) + 1;
|
|
const lanes = fill(Array(laneCount), "");
|
|
const grid = columnWidths.map(() => Array(laneCount));
|
|
const connectors = columnWidths.map(() => fill(Array(laneCount), 0));
|
|
for (const node of nodes) {
|
|
grid[node.level][node.lane] = node;
|
|
const children = getChildren(node);
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
let connector = 8 /* Right */;
|
|
if (child.lane === node.lane)
|
|
connector |= 4 /* Left */;
|
|
if (i > 0)
|
|
connector |= 1 /* Up */;
|
|
if (i < children.length - 1)
|
|
connector |= 2 /* Down */;
|
|
connectors[node.level][child.lane] |= connector;
|
|
}
|
|
if (children.length === 0) {
|
|
connectors[node.level][node.lane] |= 16 /* NoChildren */;
|
|
}
|
|
const parents = getParents(node);
|
|
for (let i = 0; i < parents.length; i++) {
|
|
const parent = parents[i];
|
|
let connector = 4 /* Left */;
|
|
if (i > 0)
|
|
connector |= 1 /* Up */;
|
|
if (i < parents.length - 1)
|
|
connector |= 2 /* Down */;
|
|
connectors[node.level - 1][parent.lane] |= connector;
|
|
}
|
|
}
|
|
for (let column = 0; column < columnCount; column++) {
|
|
for (let lane = 0; lane < laneCount; lane++) {
|
|
const left = column > 0 ? connectors[column - 1][lane] : 0;
|
|
const above = lane > 0 ? connectors[column][lane - 1] : 0;
|
|
let connector = connectors[column][lane];
|
|
if (!connector) {
|
|
if (left & 8 /* Right */)
|
|
connector |= 12 /* LeftRight */;
|
|
if (above & 2 /* Down */)
|
|
connector |= 3 /* UpDown */;
|
|
connectors[column][lane] = connector;
|
|
}
|
|
}
|
|
}
|
|
for (let column = 0; column < columnCount; column++) {
|
|
for (let lane = 0; lane < lanes.length; lane++) {
|
|
const connector = connectors[column][lane];
|
|
const fill2 = connector & 4 /* Left */ ? "\u2500" /* lr */ : " ";
|
|
const node = grid[column][lane];
|
|
if (!node) {
|
|
if (column < columnCount - 1) {
|
|
writeLane(lane, repeat(fill2, columnWidths[column] + 1));
|
|
}
|
|
} else {
|
|
writeLane(lane, node.text);
|
|
if (column < columnCount - 1) {
|
|
writeLane(lane, " ");
|
|
writeLane(lane, repeat(fill2, columnWidths[column] - node.text.length));
|
|
}
|
|
}
|
|
writeLane(lane, getBoxCharacter(connector));
|
|
writeLane(lane, connector & 8 /* Right */ && column < columnCount - 1 && !grid[column + 1][lane] ? "\u2500" /* lr */ : " ");
|
|
}
|
|
}
|
|
return `
|
|
${lanes.join("\n")}
|
|
`;
|
|
function writeLane(lane, text) {
|
|
lanes[lane] += text;
|
|
}
|
|
}
|
|
function getBoxCharacter(connector) {
|
|
switch (connector) {
|
|
case 3 /* UpDown */:
|
|
return "\u2502" /* ud */;
|
|
case 12 /* LeftRight */:
|
|
return "\u2500" /* lr */;
|
|
case 5 /* UpLeft */:
|
|
return "\u256F" /* ul */;
|
|
case 9 /* UpRight */:
|
|
return "\u2570" /* ur */;
|
|
case 6 /* DownLeft */:
|
|
return "\u256E" /* dl */;
|
|
case 10 /* DownRight */:
|
|
return "\u256D" /* dr */;
|
|
case 7 /* UpDownLeft */:
|
|
return "\u2524" /* udl */;
|
|
case 11 /* UpDownRight */:
|
|
return "\u251C" /* udr */;
|
|
case 13 /* UpLeftRight */:
|
|
return "\u2534" /* ulr */;
|
|
case 14 /* DownLeftRight */:
|
|
return "\u252C" /* dlr */;
|
|
case 15 /* UpDownLeftRight */:
|
|
return "\u256B" /* udlr */;
|
|
}
|
|
return " ";
|
|
}
|
|
function fill(array, value) {
|
|
if (array.fill) {
|
|
array.fill(value);
|
|
} else {
|
|
for (let i = 0; i < array.length; i++) {
|
|
array[i] = value;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function repeat(ch, length2) {
|
|
if (ch.repeat) {
|
|
return length2 > 0 ? ch.repeat(length2) : "";
|
|
}
|
|
let s = "";
|
|
while (s.length < length2) {
|
|
s += ch;
|
|
}
|
|
return s;
|
|
}
|
|
}
|
|
Debug2.formatControlFlowGraph = formatControlFlowGraph;
|
|
})(Debug || (Debug = {}));
|
|
|
|
// src/compiler/semver.ts
|
|
var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
|
|
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;
|
|
var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
|
|
var buildPartRegExp = /^[a-z0-9-]+$/i;
|
|
var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
|
|
var _Version = class {
|
|
constructor(major, minor = 0, patch = 0, prerelease = "", build2 = "") {
|
|
if (typeof major === "string") {
|
|
const result = Debug.checkDefined(tryParseComponents(major), "Invalid version");
|
|
({ major, minor, patch, prerelease, build: build2 } = result);
|
|
}
|
|
Debug.assert(major >= 0, "Invalid argument: major");
|
|
Debug.assert(minor >= 0, "Invalid argument: minor");
|
|
Debug.assert(patch >= 0, "Invalid argument: patch");
|
|
const prereleaseArray = prerelease ? isArray(prerelease) ? prerelease : prerelease.split(".") : emptyArray;
|
|
const buildArray = build2 ? isArray(build2) ? build2 : build2.split(".") : emptyArray;
|
|
Debug.assert(every(prereleaseArray, (s) => prereleasePartRegExp.test(s)), "Invalid argument: prerelease");
|
|
Debug.assert(every(buildArray, (s) => buildPartRegExp.test(s)), "Invalid argument: build");
|
|
this.major = major;
|
|
this.minor = minor;
|
|
this.patch = patch;
|
|
this.prerelease = prereleaseArray;
|
|
this.build = buildArray;
|
|
}
|
|
static tryParse(text) {
|
|
const result = tryParseComponents(text);
|
|
if (!result)
|
|
return void 0;
|
|
const { major, minor, patch, prerelease, build: build2 } = result;
|
|
return new _Version(major, minor, patch, prerelease, build2);
|
|
}
|
|
compareTo(other) {
|
|
if (this === other)
|
|
return 0 /* EqualTo */;
|
|
if (other === void 0)
|
|
return 1 /* GreaterThan */;
|
|
return compareValues(this.major, other.major) || compareValues(this.minor, other.minor) || compareValues(this.patch, other.patch) || comparePrereleaseIdentifiers(this.prerelease, other.prerelease);
|
|
}
|
|
increment(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 Debug.assertNever(field);
|
|
}
|
|
}
|
|
with(fields) {
|
|
const {
|
|
major = this.major,
|
|
minor = this.minor,
|
|
patch = this.patch,
|
|
prerelease = this.prerelease,
|
|
build: build2 = this.build
|
|
} = fields;
|
|
return new _Version(major, minor, patch, prerelease, build2);
|
|
}
|
|
toString() {
|
|
let result = `${this.major}.${this.minor}.${this.patch}`;
|
|
if (some(this.prerelease))
|
|
result += `-${this.prerelease.join(".")}`;
|
|
if (some(this.build))
|
|
result += `+${this.build.join(".")}`;
|
|
return result;
|
|
}
|
|
};
|
|
var Version = _Version;
|
|
Version.zero = new _Version(0, 0, 0, ["0"]);
|
|
function tryParseComponents(text) {
|
|
const match = versionRegExp.exec(text);
|
|
if (!match)
|
|
return void 0;
|
|
const [, major, minor = "0", patch = "0", prerelease = "", build2 = ""] = match;
|
|
if (prerelease && !prereleaseRegExp.test(prerelease))
|
|
return void 0;
|
|
if (build2 && !buildRegExp.test(build2))
|
|
return void 0;
|
|
return {
|
|
major: parseInt(major, 10),
|
|
minor: parseInt(minor, 10),
|
|
patch: parseInt(patch, 10),
|
|
prerelease,
|
|
build: build2
|
|
};
|
|
}
|
|
function comparePrereleaseIdentifiers(left, right) {
|
|
if (left === right)
|
|
return 0 /* EqualTo */;
|
|
if (left.length === 0)
|
|
return right.length === 0 ? 0 /* EqualTo */ : 1 /* GreaterThan */;
|
|
if (right.length === 0)
|
|
return -1 /* LessThan */;
|
|
const length2 = Math.min(left.length, right.length);
|
|
for (let i = 0; i < length2; i++) {
|
|
const leftIdentifier = left[i];
|
|
const rightIdentifier = right[i];
|
|
if (leftIdentifier === rightIdentifier)
|
|
continue;
|
|
const leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier);
|
|
const rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier);
|
|
if (leftIsNumeric || rightIsNumeric) {
|
|
if (leftIsNumeric !== rightIsNumeric)
|
|
return leftIsNumeric ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
const result = compareValues(+leftIdentifier, +rightIdentifier);
|
|
if (result)
|
|
return result;
|
|
} else {
|
|
const result = compareStringsCaseSensitive(leftIdentifier, rightIdentifier);
|
|
if (result)
|
|
return result;
|
|
}
|
|
}
|
|
return compareValues(left.length, right.length);
|
|
}
|
|
var VersionRange = class {
|
|
constructor(spec) {
|
|
this._alternatives = spec ? Debug.checkDefined(parseRange(spec), "Invalid range spec.") : emptyArray;
|
|
}
|
|
static tryParse(text) {
|
|
const sets = parseRange(text);
|
|
if (sets) {
|
|
const range = new VersionRange("");
|
|
range._alternatives = sets;
|
|
return range;
|
|
}
|
|
return void 0;
|
|
}
|
|
test(version2) {
|
|
if (typeof version2 === "string")
|
|
version2 = new Version(version2);
|
|
return testDisjunction(version2, this._alternatives);
|
|
}
|
|
toString() {
|
|
return formatDisjunction(this._alternatives);
|
|
}
|
|
};
|
|
var logicalOrRegExp = /\|\|/g;
|
|
var whitespaceRegExp = /\s+/g;
|
|
var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
|
|
var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i;
|
|
var rangeRegExp = /^(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i;
|
|
function parseRange(text) {
|
|
const alternatives = [];
|
|
for (let range of trimString(text).split(logicalOrRegExp)) {
|
|
if (!range)
|
|
continue;
|
|
const comparators = [];
|
|
range = trimString(range);
|
|
const match = hyphenRegExp.exec(range);
|
|
if (match) {
|
|
if (!parseHyphen(match[1], match[2], comparators))
|
|
return void 0;
|
|
} else {
|
|
for (const simple of range.split(whitespaceRegExp)) {
|
|
const match2 = rangeRegExp.exec(trimString(simple));
|
|
if (!match2 || !parseComparator(match2[1], match2[2], comparators))
|
|
return void 0;
|
|
}
|
|
}
|
|
alternatives.push(comparators);
|
|
}
|
|
return alternatives;
|
|
}
|
|
function parsePartial(text) {
|
|
const match = partialRegExp.exec(text);
|
|
if (!match)
|
|
return void 0;
|
|
const [, major, minor = "*", patch = "*", prerelease, build2] = match;
|
|
const version2 = 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,
|
|
build2
|
|
);
|
|
return { version: version2, major, minor, patch };
|
|
}
|
|
function parseHyphen(left, right, comparators) {
|
|
const leftResult = parsePartial(left);
|
|
if (!leftResult)
|
|
return false;
|
|
const 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) {
|
|
const result = parsePartial(text);
|
|
if (!result)
|
|
return false;
|
|
const { version: version2, major, minor, patch } = result;
|
|
if (!isWildcard(major)) {
|
|
switch (operator) {
|
|
case "~":
|
|
comparators.push(createComparator(">=", version2));
|
|
comparators.push(createComparator("<", version2.increment(
|
|
isWildcard(minor) ? "major" : "minor"
|
|
)));
|
|
break;
|
|
case "^":
|
|
comparators.push(createComparator(">=", version2));
|
|
comparators.push(createComparator("<", version2.increment(
|
|
version2.major > 0 || isWildcard(minor) ? "major" : version2.minor > 0 || isWildcard(patch) ? "minor" : "patch"
|
|
)));
|
|
break;
|
|
case "<":
|
|
case ">=":
|
|
comparators.push(
|
|
isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version2.with({ prerelease: "0" })) : createComparator(operator, version2)
|
|
);
|
|
break;
|
|
case "<=":
|
|
case ">":
|
|
comparators.push(
|
|
isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("major").with({ prerelease: "0" })) : isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("minor").with({ prerelease: "0" })) : createComparator(operator, version2)
|
|
);
|
|
break;
|
|
case "=":
|
|
case void 0:
|
|
if (isWildcard(minor) || isWildcard(patch)) {
|
|
comparators.push(createComparator(">=", version2.with({ prerelease: "0" })));
|
|
comparators.push(createComparator("<", version2.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
|
|
} else {
|
|
comparators.push(createComparator("=", version2));
|
|
}
|
|
break;
|
|
default:
|
|
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, operand };
|
|
}
|
|
function testDisjunction(version2, alternatives) {
|
|
if (alternatives.length === 0)
|
|
return true;
|
|
for (const alternative of alternatives) {
|
|
if (testAlternative(version2, alternative))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function testAlternative(version2, comparators) {
|
|
for (const comparator of comparators) {
|
|
if (!testComparator(version2, comparator.operator, comparator.operand))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function testComparator(version2, operator, operand) {
|
|
const cmp = version2.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 Debug.assertNever(operator);
|
|
}
|
|
}
|
|
function formatDisjunction(alternatives) {
|
|
return map(alternatives, formatAlternative).join(" || ") || "*";
|
|
}
|
|
function formatAlternative(comparators) {
|
|
return map(comparators, formatComparator).join(" ");
|
|
}
|
|
function formatComparator(comparator) {
|
|
return `${comparator.operator}${comparator.operand}`;
|
|
}
|
|
|
|
// src/compiler/performanceCore.ts
|
|
function hasRequiredAPI(performance2, PerformanceObserver2) {
|
|
return typeof performance2 === "object" && typeof performance2.timeOrigin === "number" && typeof performance2.mark === "function" && typeof performance2.measure === "function" && typeof performance2.now === "function" && typeof performance2.clearMarks === "function" && typeof performance2.clearMeasures === "function" && typeof PerformanceObserver2 === "function";
|
|
}
|
|
function tryGetWebPerformanceHooks() {
|
|
if (typeof performance === "object" && typeof PerformanceObserver === "function" && hasRequiredAPI(performance, PerformanceObserver)) {
|
|
return {
|
|
shouldWriteNativeEvents: true,
|
|
performance,
|
|
PerformanceObserver
|
|
};
|
|
}
|
|
}
|
|
function tryGetNodePerformanceHooks() {
|
|
if (isNodeLikeSystem()) {
|
|
try {
|
|
let performance2;
|
|
const { performance: nodePerformance, PerformanceObserver: PerformanceObserver2 } = require("perf_hooks");
|
|
if (hasRequiredAPI(nodePerformance, PerformanceObserver2)) {
|
|
performance2 = nodePerformance;
|
|
const version2 = new Version(process.versions.node);
|
|
const range = new VersionRange("<12.16.3 || 13 <13.13");
|
|
if (range.test(version2)) {
|
|
performance2 = {
|
|
get timeOrigin() {
|
|
return nodePerformance.timeOrigin;
|
|
},
|
|
now() {
|
|
return nodePerformance.now();
|
|
},
|
|
mark(name) {
|
|
return nodePerformance.mark(name);
|
|
},
|
|
measure(name, start = "nodeStart", end) {
|
|
if (end === void 0) {
|
|
end = "__performance.measure-fix__";
|
|
nodePerformance.mark(end);
|
|
}
|
|
nodePerformance.measure(name, start, end);
|
|
if (end === "__performance.measure-fix__") {
|
|
nodePerformance.clearMarks("__performance.measure-fix__");
|
|
}
|
|
},
|
|
clearMarks(name) {
|
|
return nodePerformance.clearMarks(name);
|
|
},
|
|
clearMeasures(name) {
|
|
return nodePerformance.clearMeasures(name);
|
|
}
|
|
};
|
|
}
|
|
return {
|
|
shouldWriteNativeEvents: false,
|
|
performance: performance2,
|
|
PerformanceObserver: PerformanceObserver2
|
|
};
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
var nativePerformanceHooks = tryGetWebPerformanceHooks() || tryGetNodePerformanceHooks();
|
|
var nativePerformance = nativePerformanceHooks == null ? void 0 : nativePerformanceHooks.performance;
|
|
function tryGetNativePerformanceHooks() {
|
|
return nativePerformanceHooks;
|
|
}
|
|
var timestamp = nativePerformance ? () => nativePerformance.now() : Date.now ? Date.now : () => +new Date();
|
|
|
|
// src/compiler/perfLogger.ts
|
|
var nullLogger = {
|
|
logEvent: noop,
|
|
logErrEvent: noop,
|
|
logPerfEvent: noop,
|
|
logInfoEvent: noop,
|
|
logStartCommand: noop,
|
|
logStopCommand: noop,
|
|
logStartUpdateProgram: noop,
|
|
logStopUpdateProgram: noop,
|
|
logStartUpdateGraph: noop,
|
|
logStopUpdateGraph: noop,
|
|
logStartResolveModule: noop,
|
|
logStopResolveModule: noop,
|
|
logStartParseSourceFile: noop,
|
|
logStopParseSourceFile: noop,
|
|
logStartReadFile: noop,
|
|
logStopReadFile: noop,
|
|
logStartBindFile: noop,
|
|
logStopBindFile: noop,
|
|
logStartScheduledOperation: noop,
|
|
logStopScheduledOperation: noop
|
|
};
|
|
var etwModule;
|
|
var _a;
|
|
try {
|
|
const etwModulePath = (_a = process.env.TS_ETW_MODULE_PATH) != null ? _a : "./node_modules/@microsoft/typescript-etw";
|
|
etwModule = require(etwModulePath);
|
|
} catch (e) {
|
|
etwModule = void 0;
|
|
}
|
|
var perfLogger = (etwModule == null ? void 0 : etwModule.logEvent) ? etwModule : nullLogger;
|
|
|
|
// src/compiler/_namespaces/ts.performance.ts
|
|
var ts_performance_exports = {};
|
|
__export(ts_performance_exports, {
|
|
clearMarks: () => clearMarks,
|
|
clearMeasures: () => clearMeasures,
|
|
createTimer: () => createTimer,
|
|
createTimerIf: () => createTimerIf,
|
|
disable: () => disable,
|
|
enable: () => enable,
|
|
forEachMark: () => forEachMark,
|
|
forEachMeasure: () => forEachMeasure,
|
|
getCount: () => getCount,
|
|
getDuration: () => getDuration,
|
|
isEnabled: () => isEnabled,
|
|
mark: () => mark,
|
|
measure: () => measure,
|
|
nullTimer: () => nullTimer
|
|
});
|
|
|
|
// src/compiler/performance.ts
|
|
var perfHooks;
|
|
var performanceImpl;
|
|
function createTimerIf(condition, measureName, startMarkName, endMarkName) {
|
|
return condition ? createTimer(measureName, startMarkName, endMarkName) : nullTimer;
|
|
}
|
|
function createTimer(measureName, startMarkName, endMarkName) {
|
|
let enterCount = 0;
|
|
return {
|
|
enter,
|
|
exit
|
|
};
|
|
function enter() {
|
|
if (++enterCount === 1) {
|
|
mark(startMarkName);
|
|
}
|
|
}
|
|
function exit() {
|
|
if (--enterCount === 0) {
|
|
mark(endMarkName);
|
|
measure(measureName, startMarkName, endMarkName);
|
|
} else if (enterCount < 0) {
|
|
Debug.fail("enter/exit count does not match.");
|
|
}
|
|
}
|
|
}
|
|
var nullTimer = { enter: noop, exit: noop };
|
|
var enabled = false;
|
|
var timeorigin = timestamp();
|
|
var marks = /* @__PURE__ */ new Map();
|
|
var counts = /* @__PURE__ */ new Map();
|
|
var durations = /* @__PURE__ */ new Map();
|
|
function mark(markName) {
|
|
var _a2;
|
|
if (enabled) {
|
|
const count = (_a2 = counts.get(markName)) != null ? _a2 : 0;
|
|
counts.set(markName, count + 1);
|
|
marks.set(markName, timestamp());
|
|
performanceImpl == null ? void 0 : performanceImpl.mark(markName);
|
|
}
|
|
}
|
|
function measure(measureName, startMarkName, endMarkName) {
|
|
var _a2, _b;
|
|
if (enabled) {
|
|
const end = (_a2 = endMarkName !== void 0 ? marks.get(endMarkName) : void 0) != null ? _a2 : timestamp();
|
|
const start = (_b = startMarkName !== void 0 ? marks.get(startMarkName) : void 0) != null ? _b : timeorigin;
|
|
const previousDuration = durations.get(measureName) || 0;
|
|
durations.set(measureName, previousDuration + (end - start));
|
|
performanceImpl == null ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName);
|
|
}
|
|
}
|
|
function getCount(markName) {
|
|
return counts.get(markName) || 0;
|
|
}
|
|
function getDuration(measureName) {
|
|
return durations.get(measureName) || 0;
|
|
}
|
|
function forEachMeasure(cb) {
|
|
durations.forEach((duration, measureName) => cb(measureName, duration));
|
|
}
|
|
function forEachMark(cb) {
|
|
marks.forEach((_time, markName) => cb(markName));
|
|
}
|
|
function clearMeasures(name) {
|
|
if (name !== void 0)
|
|
durations.delete(name);
|
|
else
|
|
durations.clear();
|
|
performanceImpl == null ? void 0 : performanceImpl.clearMeasures(name);
|
|
}
|
|
function clearMarks(name) {
|
|
if (name !== void 0) {
|
|
counts.delete(name);
|
|
marks.delete(name);
|
|
} else {
|
|
counts.clear();
|
|
marks.clear();
|
|
}
|
|
performanceImpl == null ? void 0 : performanceImpl.clearMarks(name);
|
|
}
|
|
function isEnabled() {
|
|
return enabled;
|
|
}
|
|
function enable(system = sys) {
|
|
var _a2;
|
|
if (!enabled) {
|
|
enabled = true;
|
|
perfHooks || (perfHooks = tryGetNativePerformanceHooks());
|
|
if (perfHooks) {
|
|
timeorigin = perfHooks.performance.timeOrigin;
|
|
if (perfHooks.shouldWriteNativeEvents || ((_a2 = system == null ? void 0 : system.cpuProfilingEnabled) == null ? void 0 : _a2.call(system)) || (system == null ? void 0 : system.debugMode)) {
|
|
performanceImpl = perfHooks.performance;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function disable() {
|
|
if (enabled) {
|
|
marks.clear();
|
|
counts.clear();
|
|
durations.clear();
|
|
performanceImpl = void 0;
|
|
enabled = false;
|
|
}
|
|
}
|
|
|
|
// src/compiler/tracing.ts
|
|
var tracing;
|
|
var tracingEnabled;
|
|
((tracingEnabled2) => {
|
|
let fs;
|
|
let traceCount = 0;
|
|
let traceFd = 0;
|
|
let mode;
|
|
const typeCatalog = [];
|
|
let legendPath;
|
|
const legend = [];
|
|
function startTracing2(tracingMode, traceDir, configFilePath) {
|
|
Debug.assert(!tracing, "Tracing already started");
|
|
if (fs === void 0) {
|
|
try {
|
|
fs = require("fs");
|
|
} catch (e) {
|
|
throw new Error(`tracing requires having fs
|
|
(original error: ${e.message || e})`);
|
|
}
|
|
}
|
|
mode = tracingMode;
|
|
typeCatalog.length = 0;
|
|
if (legendPath === void 0) {
|
|
legendPath = combinePaths(traceDir, "legend.json");
|
|
}
|
|
if (!fs.existsSync(traceDir)) {
|
|
fs.mkdirSync(traceDir, { recursive: true });
|
|
}
|
|
const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
|
|
const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
|
|
const typesPath = combinePaths(traceDir, `types${countPart}.json`);
|
|
legend.push({
|
|
configFilePath,
|
|
tracePath,
|
|
typesPath
|
|
});
|
|
traceFd = fs.openSync(tracePath, "w");
|
|
tracing = tracingEnabled2;
|
|
const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
|
|
fs.writeSync(
|
|
traceFd,
|
|
"[\n" + [
|
|
{ name: "process_name", args: { name: "tsc" }, ...meta },
|
|
{ name: "thread_name", args: { name: "Main" }, ...meta },
|
|
{ name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }
|
|
].map((v) => JSON.stringify(v)).join(",\n")
|
|
);
|
|
}
|
|
tracingEnabled2.startTracing = startTracing2;
|
|
function stopTracing() {
|
|
Debug.assert(tracing, "Tracing is not in progress");
|
|
Debug.assert(!!typeCatalog.length === (mode !== "server"));
|
|
fs.writeSync(traceFd, `
|
|
]
|
|
`);
|
|
fs.closeSync(traceFd);
|
|
tracing = void 0;
|
|
if (typeCatalog.length) {
|
|
dumpTypes(typeCatalog);
|
|
} else {
|
|
legend[legend.length - 1].typesPath = void 0;
|
|
}
|
|
}
|
|
tracingEnabled2.stopTracing = stopTracing;
|
|
function recordType(type) {
|
|
if (mode !== "server") {
|
|
typeCatalog.push(type);
|
|
}
|
|
}
|
|
tracingEnabled2.recordType = recordType;
|
|
let Phase;
|
|
((Phase2) => {
|
|
Phase2["Parse"] = "parse";
|
|
Phase2["Program"] = "program";
|
|
Phase2["Bind"] = "bind";
|
|
Phase2["Check"] = "check";
|
|
Phase2["CheckTypes"] = "checkTypes";
|
|
Phase2["Emit"] = "emit";
|
|
Phase2["Session"] = "session";
|
|
})(Phase = tracingEnabled2.Phase || (tracingEnabled2.Phase = {}));
|
|
function instant(phase, name, args) {
|
|
writeEvent("I", phase, name, args, `"s":"g"`);
|
|
}
|
|
tracingEnabled2.instant = instant;
|
|
const eventStack = [];
|
|
function push(phase, name, args, separateBeginAndEnd = false) {
|
|
if (separateBeginAndEnd) {
|
|
writeEvent("B", phase, name, args);
|
|
}
|
|
eventStack.push({ phase, name, args, time: 1e3 * timestamp(), separateBeginAndEnd });
|
|
}
|
|
tracingEnabled2.push = push;
|
|
function pop(results) {
|
|
Debug.assert(eventStack.length > 0);
|
|
writeStackEvent(eventStack.length - 1, 1e3 * timestamp(), results);
|
|
eventStack.length--;
|
|
}
|
|
tracingEnabled2.pop = pop;
|
|
function popAll() {
|
|
const endTime = 1e3 * timestamp();
|
|
for (let i = eventStack.length - 1; i >= 0; i--) {
|
|
writeStackEvent(i, endTime);
|
|
}
|
|
eventStack.length = 0;
|
|
}
|
|
tracingEnabled2.popAll = popAll;
|
|
const sampleInterval = 1e3 * 10;
|
|
function writeStackEvent(index, endTime, results) {
|
|
const { phase, name, args, time, separateBeginAndEnd } = eventStack[index];
|
|
if (separateBeginAndEnd) {
|
|
Debug.assert(!results, "`results` are not supported for events with `separateBeginAndEnd`");
|
|
writeEvent("E", phase, name, args, void 0, endTime);
|
|
} else if (sampleInterval - time % sampleInterval <= endTime - time) {
|
|
writeEvent("X", phase, name, { ...args, results }, `"dur":${endTime - time}`, time);
|
|
}
|
|
}
|
|
function writeEvent(eventType, phase, name, args, extras, time = 1e3 * timestamp()) {
|
|
if (mode === "server" && phase === "checkTypes" /* CheckTypes */)
|
|
return;
|
|
mark("beginTracing");
|
|
fs.writeSync(traceFd, `,
|
|
{"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
|
|
if (extras)
|
|
fs.writeSync(traceFd, `,${extras}`);
|
|
if (args)
|
|
fs.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
|
|
fs.writeSync(traceFd, `}`);
|
|
mark("endTracing");
|
|
measure("Tracing", "beginTracing", "endTracing");
|
|
}
|
|
function getLocation(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return !file ? void 0 : {
|
|
path: file.path,
|
|
start: indexFromOne(getLineAndCharacterOfPosition(file, node.pos)),
|
|
end: indexFromOne(getLineAndCharacterOfPosition(file, node.end))
|
|
};
|
|
function indexFromOne(lc) {
|
|
return {
|
|
line: lc.line + 1,
|
|
character: lc.character + 1
|
|
};
|
|
}
|
|
}
|
|
function dumpTypes(types) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
|
|
mark("beginDumpTypes");
|
|
const typesPath = legend[legend.length - 1].typesPath;
|
|
const typesFd = fs.openSync(typesPath, "w");
|
|
const recursionIdentityMap = /* @__PURE__ */ new Map();
|
|
fs.writeSync(typesFd, "[");
|
|
const numTypes = types.length;
|
|
for (let i = 0; i < numTypes; i++) {
|
|
const type = types[i];
|
|
const objectFlags = type.objectFlags;
|
|
const symbol = (_a2 = type.aliasSymbol) != null ? _a2 : type.symbol;
|
|
let display;
|
|
if (objectFlags & 16 /* Anonymous */ | type.flags & 2944 /* Literal */) {
|
|
try {
|
|
display = (_b = type.checker) == null ? void 0 : _b.typeToString(type);
|
|
} catch (e) {
|
|
display = void 0;
|
|
}
|
|
}
|
|
let indexedAccessProperties = {};
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
const indexedAccessType = type;
|
|
indexedAccessProperties = {
|
|
indexedAccessObjectType: (_c = indexedAccessType.objectType) == null ? void 0 : _c.id,
|
|
indexedAccessIndexType: (_d = indexedAccessType.indexType) == null ? void 0 : _d.id
|
|
};
|
|
}
|
|
let referenceProperties = {};
|
|
if (objectFlags & 4 /* Reference */) {
|
|
const referenceType = type;
|
|
referenceProperties = {
|
|
instantiatedType: (_e = referenceType.target) == null ? void 0 : _e.id,
|
|
typeArguments: (_f = referenceType.resolvedTypeArguments) == null ? void 0 : _f.map((t) => t.id),
|
|
referenceLocation: getLocation(referenceType.node)
|
|
};
|
|
}
|
|
let conditionalProperties = {};
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
const conditionalType = type;
|
|
conditionalProperties = {
|
|
conditionalCheckType: (_g = conditionalType.checkType) == null ? void 0 : _g.id,
|
|
conditionalExtendsType: (_h = conditionalType.extendsType) == null ? void 0 : _h.id,
|
|
conditionalTrueType: (_j = (_i = conditionalType.resolvedTrueType) == null ? void 0 : _i.id) != null ? _j : -1,
|
|
conditionalFalseType: (_l = (_k = conditionalType.resolvedFalseType) == null ? void 0 : _k.id) != null ? _l : -1
|
|
};
|
|
}
|
|
let substitutionProperties = {};
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
const substitutionType = type;
|
|
substitutionProperties = {
|
|
substitutionBaseType: (_m = substitutionType.baseType) == null ? void 0 : _m.id,
|
|
constraintType: (_n = substitutionType.constraint) == null ? void 0 : _n.id
|
|
};
|
|
}
|
|
let reverseMappedProperties = {};
|
|
if (objectFlags & 1024 /* ReverseMapped */) {
|
|
const reverseMappedType = type;
|
|
reverseMappedProperties = {
|
|
reverseMappedSourceType: (_o = reverseMappedType.source) == null ? void 0 : _o.id,
|
|
reverseMappedMappedType: (_p = reverseMappedType.mappedType) == null ? void 0 : _p.id,
|
|
reverseMappedConstraintType: (_q = reverseMappedType.constraintType) == null ? void 0 : _q.id
|
|
};
|
|
}
|
|
let evolvingArrayProperties = {};
|
|
if (objectFlags & 256 /* EvolvingArray */) {
|
|
const evolvingArrayType = type;
|
|
evolvingArrayProperties = {
|
|
evolvingArrayElementType: evolvingArrayType.elementType.id,
|
|
evolvingArrayFinalType: (_r = evolvingArrayType.finalArrayType) == null ? void 0 : _r.id
|
|
};
|
|
}
|
|
let recursionToken;
|
|
const recursionIdentity = type.checker.getRecursionIdentity(type);
|
|
if (recursionIdentity) {
|
|
recursionToken = recursionIdentityMap.get(recursionIdentity);
|
|
if (!recursionToken) {
|
|
recursionToken = recursionIdentityMap.size;
|
|
recursionIdentityMap.set(recursionIdentity, recursionToken);
|
|
}
|
|
}
|
|
const descriptor = {
|
|
id: type.id,
|
|
intrinsicName: type.intrinsicName,
|
|
symbolName: (symbol == null ? void 0 : symbol.escapedName) && unescapeLeadingUnderscores(symbol.escapedName),
|
|
recursionId: recursionToken,
|
|
isTuple: objectFlags & 8 /* Tuple */ ? true : void 0,
|
|
unionTypes: type.flags & 1048576 /* Union */ ? (_s = type.types) == null ? void 0 : _s.map((t) => t.id) : void 0,
|
|
intersectionTypes: type.flags & 2097152 /* Intersection */ ? type.types.map((t) => t.id) : void 0,
|
|
aliasTypeArguments: (_t = type.aliasTypeArguments) == null ? void 0 : _t.map((t) => t.id),
|
|
keyofType: type.flags & 4194304 /* Index */ ? (_u = type.type) == null ? void 0 : _u.id : void 0,
|
|
...indexedAccessProperties,
|
|
...referenceProperties,
|
|
...conditionalProperties,
|
|
...substitutionProperties,
|
|
...reverseMappedProperties,
|
|
...evolvingArrayProperties,
|
|
destructuringPattern: getLocation(type.pattern),
|
|
firstDeclaration: getLocation((_v = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _v[0]),
|
|
flags: Debug.formatTypeFlags(type.flags).split("|"),
|
|
display
|
|
};
|
|
fs.writeSync(typesFd, JSON.stringify(descriptor));
|
|
if (i < numTypes - 1) {
|
|
fs.writeSync(typesFd, ",\n");
|
|
}
|
|
}
|
|
fs.writeSync(typesFd, "]\n");
|
|
fs.closeSync(typesFd);
|
|
mark("endDumpTypes");
|
|
measure("Dump types", "beginDumpTypes", "endDumpTypes");
|
|
}
|
|
function dumpLegend() {
|
|
if (!legendPath) {
|
|
return;
|
|
}
|
|
fs.writeFileSync(legendPath, JSON.stringify(legend));
|
|
}
|
|
tracingEnabled2.dumpLegend = dumpLegend;
|
|
})(tracingEnabled || (tracingEnabled = {}));
|
|
var startTracing = tracingEnabled.startTracing;
|
|
var dumpTracingLegend = tracingEnabled.dumpLegend;
|
|
|
|
// src/compiler/types.ts
|
|
var SyntaxKind = /* @__PURE__ */ ((SyntaxKind4) => {
|
|
SyntaxKind4[SyntaxKind4["Unknown"] = 0] = "Unknown";
|
|
SyntaxKind4[SyntaxKind4["EndOfFileToken"] = 1] = "EndOfFileToken";
|
|
SyntaxKind4[SyntaxKind4["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia";
|
|
SyntaxKind4[SyntaxKind4["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia";
|
|
SyntaxKind4[SyntaxKind4["NewLineTrivia"] = 4] = "NewLineTrivia";
|
|
SyntaxKind4[SyntaxKind4["WhitespaceTrivia"] = 5] = "WhitespaceTrivia";
|
|
SyntaxKind4[SyntaxKind4["ShebangTrivia"] = 6] = "ShebangTrivia";
|
|
SyntaxKind4[SyntaxKind4["ConflictMarkerTrivia"] = 7] = "ConflictMarkerTrivia";
|
|
SyntaxKind4[SyntaxKind4["NumericLiteral"] = 8] = "NumericLiteral";
|
|
SyntaxKind4[SyntaxKind4["BigIntLiteral"] = 9] = "BigIntLiteral";
|
|
SyntaxKind4[SyntaxKind4["StringLiteral"] = 10] = "StringLiteral";
|
|
SyntaxKind4[SyntaxKind4["JsxText"] = 11] = "JsxText";
|
|
SyntaxKind4[SyntaxKind4["JsxTextAllWhiteSpaces"] = 12] = "JsxTextAllWhiteSpaces";
|
|
SyntaxKind4[SyntaxKind4["RegularExpressionLiteral"] = 13] = "RegularExpressionLiteral";
|
|
SyntaxKind4[SyntaxKind4["NoSubstitutionTemplateLiteral"] = 14] = "NoSubstitutionTemplateLiteral";
|
|
SyntaxKind4[SyntaxKind4["TemplateHead"] = 15] = "TemplateHead";
|
|
SyntaxKind4[SyntaxKind4["TemplateMiddle"] = 16] = "TemplateMiddle";
|
|
SyntaxKind4[SyntaxKind4["TemplateTail"] = 17] = "TemplateTail";
|
|
SyntaxKind4[SyntaxKind4["OpenBraceToken"] = 18] = "OpenBraceToken";
|
|
SyntaxKind4[SyntaxKind4["CloseBraceToken"] = 19] = "CloseBraceToken";
|
|
SyntaxKind4[SyntaxKind4["OpenParenToken"] = 20] = "OpenParenToken";
|
|
SyntaxKind4[SyntaxKind4["CloseParenToken"] = 21] = "CloseParenToken";
|
|
SyntaxKind4[SyntaxKind4["OpenBracketToken"] = 22] = "OpenBracketToken";
|
|
SyntaxKind4[SyntaxKind4["CloseBracketToken"] = 23] = "CloseBracketToken";
|
|
SyntaxKind4[SyntaxKind4["DotToken"] = 24] = "DotToken";
|
|
SyntaxKind4[SyntaxKind4["DotDotDotToken"] = 25] = "DotDotDotToken";
|
|
SyntaxKind4[SyntaxKind4["SemicolonToken"] = 26] = "SemicolonToken";
|
|
SyntaxKind4[SyntaxKind4["CommaToken"] = 27] = "CommaToken";
|
|
SyntaxKind4[SyntaxKind4["QuestionDotToken"] = 28] = "QuestionDotToken";
|
|
SyntaxKind4[SyntaxKind4["LessThanToken"] = 29] = "LessThanToken";
|
|
SyntaxKind4[SyntaxKind4["LessThanSlashToken"] = 30] = "LessThanSlashToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanToken"] = 31] = "GreaterThanToken";
|
|
SyntaxKind4[SyntaxKind4["LessThanEqualsToken"] = 32] = "LessThanEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanEqualsToken"] = 33] = "GreaterThanEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["EqualsEqualsToken"] = 34] = "EqualsEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["ExclamationEqualsToken"] = 35] = "ExclamationEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["EqualsEqualsEqualsToken"] = 36] = "EqualsEqualsEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["ExclamationEqualsEqualsToken"] = 37] = "ExclamationEqualsEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["EqualsGreaterThanToken"] = 38] = "EqualsGreaterThanToken";
|
|
SyntaxKind4[SyntaxKind4["PlusToken"] = 39] = "PlusToken";
|
|
SyntaxKind4[SyntaxKind4["MinusToken"] = 40] = "MinusToken";
|
|
SyntaxKind4[SyntaxKind4["AsteriskToken"] = 41] = "AsteriskToken";
|
|
SyntaxKind4[SyntaxKind4["AsteriskAsteriskToken"] = 42] = "AsteriskAsteriskToken";
|
|
SyntaxKind4[SyntaxKind4["SlashToken"] = 43] = "SlashToken";
|
|
SyntaxKind4[SyntaxKind4["PercentToken"] = 44] = "PercentToken";
|
|
SyntaxKind4[SyntaxKind4["PlusPlusToken"] = 45] = "PlusPlusToken";
|
|
SyntaxKind4[SyntaxKind4["MinusMinusToken"] = 46] = "MinusMinusToken";
|
|
SyntaxKind4[SyntaxKind4["LessThanLessThanToken"] = 47] = "LessThanLessThanToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanGreaterThanToken"] = 48] = "GreaterThanGreaterThanToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanGreaterThanGreaterThanToken"] = 49] = "GreaterThanGreaterThanGreaterThanToken";
|
|
SyntaxKind4[SyntaxKind4["AmpersandToken"] = 50] = "AmpersandToken";
|
|
SyntaxKind4[SyntaxKind4["BarToken"] = 51] = "BarToken";
|
|
SyntaxKind4[SyntaxKind4["CaretToken"] = 52] = "CaretToken";
|
|
SyntaxKind4[SyntaxKind4["ExclamationToken"] = 53] = "ExclamationToken";
|
|
SyntaxKind4[SyntaxKind4["TildeToken"] = 54] = "TildeToken";
|
|
SyntaxKind4[SyntaxKind4["AmpersandAmpersandToken"] = 55] = "AmpersandAmpersandToken";
|
|
SyntaxKind4[SyntaxKind4["BarBarToken"] = 56] = "BarBarToken";
|
|
SyntaxKind4[SyntaxKind4["QuestionToken"] = 57] = "QuestionToken";
|
|
SyntaxKind4[SyntaxKind4["ColonToken"] = 58] = "ColonToken";
|
|
SyntaxKind4[SyntaxKind4["AtToken"] = 59] = "AtToken";
|
|
SyntaxKind4[SyntaxKind4["QuestionQuestionToken"] = 60] = "QuestionQuestionToken";
|
|
SyntaxKind4[SyntaxKind4["BacktickToken"] = 61] = "BacktickToken";
|
|
SyntaxKind4[SyntaxKind4["HashToken"] = 62] = "HashToken";
|
|
SyntaxKind4[SyntaxKind4["EqualsToken"] = 63] = "EqualsToken";
|
|
SyntaxKind4[SyntaxKind4["PlusEqualsToken"] = 64] = "PlusEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["MinusEqualsToken"] = 65] = "MinusEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["AsteriskEqualsToken"] = 66] = "AsteriskEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["AsteriskAsteriskEqualsToken"] = 67] = "AsteriskAsteriskEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["SlashEqualsToken"] = 68] = "SlashEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["PercentEqualsToken"] = 69] = "PercentEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["LessThanLessThanEqualsToken"] = 70] = "LessThanLessThanEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanGreaterThanEqualsToken"] = 71] = "GreaterThanGreaterThanEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["GreaterThanGreaterThanGreaterThanEqualsToken"] = 72] = "GreaterThanGreaterThanGreaterThanEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["AmpersandEqualsToken"] = 73] = "AmpersandEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["BarEqualsToken"] = 74] = "BarEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["BarBarEqualsToken"] = 75] = "BarBarEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["AmpersandAmpersandEqualsToken"] = 76] = "AmpersandAmpersandEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["QuestionQuestionEqualsToken"] = 77] = "QuestionQuestionEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["CaretEqualsToken"] = 78] = "CaretEqualsToken";
|
|
SyntaxKind4[SyntaxKind4["Identifier"] = 79] = "Identifier";
|
|
SyntaxKind4[SyntaxKind4["PrivateIdentifier"] = 80] = "PrivateIdentifier";
|
|
SyntaxKind4[SyntaxKind4["BreakKeyword"] = 81] = "BreakKeyword";
|
|
SyntaxKind4[SyntaxKind4["CaseKeyword"] = 82] = "CaseKeyword";
|
|
SyntaxKind4[SyntaxKind4["CatchKeyword"] = 83] = "CatchKeyword";
|
|
SyntaxKind4[SyntaxKind4["ClassKeyword"] = 84] = "ClassKeyword";
|
|
SyntaxKind4[SyntaxKind4["ConstKeyword"] = 85] = "ConstKeyword";
|
|
SyntaxKind4[SyntaxKind4["ContinueKeyword"] = 86] = "ContinueKeyword";
|
|
SyntaxKind4[SyntaxKind4["DebuggerKeyword"] = 87] = "DebuggerKeyword";
|
|
SyntaxKind4[SyntaxKind4["DefaultKeyword"] = 88] = "DefaultKeyword";
|
|
SyntaxKind4[SyntaxKind4["DeleteKeyword"] = 89] = "DeleteKeyword";
|
|
SyntaxKind4[SyntaxKind4["DoKeyword"] = 90] = "DoKeyword";
|
|
SyntaxKind4[SyntaxKind4["ElseKeyword"] = 91] = "ElseKeyword";
|
|
SyntaxKind4[SyntaxKind4["EnumKeyword"] = 92] = "EnumKeyword";
|
|
SyntaxKind4[SyntaxKind4["ExportKeyword"] = 93] = "ExportKeyword";
|
|
SyntaxKind4[SyntaxKind4["ExtendsKeyword"] = 94] = "ExtendsKeyword";
|
|
SyntaxKind4[SyntaxKind4["FalseKeyword"] = 95] = "FalseKeyword";
|
|
SyntaxKind4[SyntaxKind4["FinallyKeyword"] = 96] = "FinallyKeyword";
|
|
SyntaxKind4[SyntaxKind4["ForKeyword"] = 97] = "ForKeyword";
|
|
SyntaxKind4[SyntaxKind4["FunctionKeyword"] = 98] = "FunctionKeyword";
|
|
SyntaxKind4[SyntaxKind4["IfKeyword"] = 99] = "IfKeyword";
|
|
SyntaxKind4[SyntaxKind4["ImportKeyword"] = 100] = "ImportKeyword";
|
|
SyntaxKind4[SyntaxKind4["InKeyword"] = 101] = "InKeyword";
|
|
SyntaxKind4[SyntaxKind4["InstanceOfKeyword"] = 102] = "InstanceOfKeyword";
|
|
SyntaxKind4[SyntaxKind4["NewKeyword"] = 103] = "NewKeyword";
|
|
SyntaxKind4[SyntaxKind4["NullKeyword"] = 104] = "NullKeyword";
|
|
SyntaxKind4[SyntaxKind4["ReturnKeyword"] = 105] = "ReturnKeyword";
|
|
SyntaxKind4[SyntaxKind4["SuperKeyword"] = 106] = "SuperKeyword";
|
|
SyntaxKind4[SyntaxKind4["SwitchKeyword"] = 107] = "SwitchKeyword";
|
|
SyntaxKind4[SyntaxKind4["ThisKeyword"] = 108] = "ThisKeyword";
|
|
SyntaxKind4[SyntaxKind4["ThrowKeyword"] = 109] = "ThrowKeyword";
|
|
SyntaxKind4[SyntaxKind4["TrueKeyword"] = 110] = "TrueKeyword";
|
|
SyntaxKind4[SyntaxKind4["TryKeyword"] = 111] = "TryKeyword";
|
|
SyntaxKind4[SyntaxKind4["TypeOfKeyword"] = 112] = "TypeOfKeyword";
|
|
SyntaxKind4[SyntaxKind4["VarKeyword"] = 113] = "VarKeyword";
|
|
SyntaxKind4[SyntaxKind4["VoidKeyword"] = 114] = "VoidKeyword";
|
|
SyntaxKind4[SyntaxKind4["WhileKeyword"] = 115] = "WhileKeyword";
|
|
SyntaxKind4[SyntaxKind4["WithKeyword"] = 116] = "WithKeyword";
|
|
SyntaxKind4[SyntaxKind4["ImplementsKeyword"] = 117] = "ImplementsKeyword";
|
|
SyntaxKind4[SyntaxKind4["InterfaceKeyword"] = 118] = "InterfaceKeyword";
|
|
SyntaxKind4[SyntaxKind4["LetKeyword"] = 119] = "LetKeyword";
|
|
SyntaxKind4[SyntaxKind4["PackageKeyword"] = 120] = "PackageKeyword";
|
|
SyntaxKind4[SyntaxKind4["PrivateKeyword"] = 121] = "PrivateKeyword";
|
|
SyntaxKind4[SyntaxKind4["ProtectedKeyword"] = 122] = "ProtectedKeyword";
|
|
SyntaxKind4[SyntaxKind4["PublicKeyword"] = 123] = "PublicKeyword";
|
|
SyntaxKind4[SyntaxKind4["StaticKeyword"] = 124] = "StaticKeyword";
|
|
SyntaxKind4[SyntaxKind4["YieldKeyword"] = 125] = "YieldKeyword";
|
|
SyntaxKind4[SyntaxKind4["AbstractKeyword"] = 126] = "AbstractKeyword";
|
|
SyntaxKind4[SyntaxKind4["AccessorKeyword"] = 127] = "AccessorKeyword";
|
|
SyntaxKind4[SyntaxKind4["AsKeyword"] = 128] = "AsKeyword";
|
|
SyntaxKind4[SyntaxKind4["AssertsKeyword"] = 129] = "AssertsKeyword";
|
|
SyntaxKind4[SyntaxKind4["AssertKeyword"] = 130] = "AssertKeyword";
|
|
SyntaxKind4[SyntaxKind4["AnyKeyword"] = 131] = "AnyKeyword";
|
|
SyntaxKind4[SyntaxKind4["AsyncKeyword"] = 132] = "AsyncKeyword";
|
|
SyntaxKind4[SyntaxKind4["AwaitKeyword"] = 133] = "AwaitKeyword";
|
|
SyntaxKind4[SyntaxKind4["BooleanKeyword"] = 134] = "BooleanKeyword";
|
|
SyntaxKind4[SyntaxKind4["ConstructorKeyword"] = 135] = "ConstructorKeyword";
|
|
SyntaxKind4[SyntaxKind4["DeclareKeyword"] = 136] = "DeclareKeyword";
|
|
SyntaxKind4[SyntaxKind4["GetKeyword"] = 137] = "GetKeyword";
|
|
SyntaxKind4[SyntaxKind4["InferKeyword"] = 138] = "InferKeyword";
|
|
SyntaxKind4[SyntaxKind4["IntrinsicKeyword"] = 139] = "IntrinsicKeyword";
|
|
SyntaxKind4[SyntaxKind4["IsKeyword"] = 140] = "IsKeyword";
|
|
SyntaxKind4[SyntaxKind4["KeyOfKeyword"] = 141] = "KeyOfKeyword";
|
|
SyntaxKind4[SyntaxKind4["ModuleKeyword"] = 142] = "ModuleKeyword";
|
|
SyntaxKind4[SyntaxKind4["NamespaceKeyword"] = 143] = "NamespaceKeyword";
|
|
SyntaxKind4[SyntaxKind4["NeverKeyword"] = 144] = "NeverKeyword";
|
|
SyntaxKind4[SyntaxKind4["OutKeyword"] = 145] = "OutKeyword";
|
|
SyntaxKind4[SyntaxKind4["ReadonlyKeyword"] = 146] = "ReadonlyKeyword";
|
|
SyntaxKind4[SyntaxKind4["RequireKeyword"] = 147] = "RequireKeyword";
|
|
SyntaxKind4[SyntaxKind4["NumberKeyword"] = 148] = "NumberKeyword";
|
|
SyntaxKind4[SyntaxKind4["ObjectKeyword"] = 149] = "ObjectKeyword";
|
|
SyntaxKind4[SyntaxKind4["SatisfiesKeyword"] = 150] = "SatisfiesKeyword";
|
|
SyntaxKind4[SyntaxKind4["SetKeyword"] = 151] = "SetKeyword";
|
|
SyntaxKind4[SyntaxKind4["StringKeyword"] = 152] = "StringKeyword";
|
|
SyntaxKind4[SyntaxKind4["SymbolKeyword"] = 153] = "SymbolKeyword";
|
|
SyntaxKind4[SyntaxKind4["TypeKeyword"] = 154] = "TypeKeyword";
|
|
SyntaxKind4[SyntaxKind4["UndefinedKeyword"] = 155] = "UndefinedKeyword";
|
|
SyntaxKind4[SyntaxKind4["UniqueKeyword"] = 156] = "UniqueKeyword";
|
|
SyntaxKind4[SyntaxKind4["UnknownKeyword"] = 157] = "UnknownKeyword";
|
|
SyntaxKind4[SyntaxKind4["FromKeyword"] = 158] = "FromKeyword";
|
|
SyntaxKind4[SyntaxKind4["GlobalKeyword"] = 159] = "GlobalKeyword";
|
|
SyntaxKind4[SyntaxKind4["BigIntKeyword"] = 160] = "BigIntKeyword";
|
|
SyntaxKind4[SyntaxKind4["OverrideKeyword"] = 161] = "OverrideKeyword";
|
|
SyntaxKind4[SyntaxKind4["OfKeyword"] = 162] = "OfKeyword";
|
|
SyntaxKind4[SyntaxKind4["QualifiedName"] = 163] = "QualifiedName";
|
|
SyntaxKind4[SyntaxKind4["ComputedPropertyName"] = 164] = "ComputedPropertyName";
|
|
SyntaxKind4[SyntaxKind4["TypeParameter"] = 165] = "TypeParameter";
|
|
SyntaxKind4[SyntaxKind4["Parameter"] = 166] = "Parameter";
|
|
SyntaxKind4[SyntaxKind4["Decorator"] = 167] = "Decorator";
|
|
SyntaxKind4[SyntaxKind4["PropertySignature"] = 168] = "PropertySignature";
|
|
SyntaxKind4[SyntaxKind4["PropertyDeclaration"] = 169] = "PropertyDeclaration";
|
|
SyntaxKind4[SyntaxKind4["MethodSignature"] = 170] = "MethodSignature";
|
|
SyntaxKind4[SyntaxKind4["MethodDeclaration"] = 171] = "MethodDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ClassStaticBlockDeclaration"] = 172] = "ClassStaticBlockDeclaration";
|
|
SyntaxKind4[SyntaxKind4["Constructor"] = 173] = "Constructor";
|
|
SyntaxKind4[SyntaxKind4["GetAccessor"] = 174] = "GetAccessor";
|
|
SyntaxKind4[SyntaxKind4["SetAccessor"] = 175] = "SetAccessor";
|
|
SyntaxKind4[SyntaxKind4["CallSignature"] = 176] = "CallSignature";
|
|
SyntaxKind4[SyntaxKind4["ConstructSignature"] = 177] = "ConstructSignature";
|
|
SyntaxKind4[SyntaxKind4["IndexSignature"] = 178] = "IndexSignature";
|
|
SyntaxKind4[SyntaxKind4["TypePredicate"] = 179] = "TypePredicate";
|
|
SyntaxKind4[SyntaxKind4["TypeReference"] = 180] = "TypeReference";
|
|
SyntaxKind4[SyntaxKind4["FunctionType"] = 181] = "FunctionType";
|
|
SyntaxKind4[SyntaxKind4["ConstructorType"] = 182] = "ConstructorType";
|
|
SyntaxKind4[SyntaxKind4["TypeQuery"] = 183] = "TypeQuery";
|
|
SyntaxKind4[SyntaxKind4["TypeLiteral"] = 184] = "TypeLiteral";
|
|
SyntaxKind4[SyntaxKind4["ArrayType"] = 185] = "ArrayType";
|
|
SyntaxKind4[SyntaxKind4["TupleType"] = 186] = "TupleType";
|
|
SyntaxKind4[SyntaxKind4["OptionalType"] = 187] = "OptionalType";
|
|
SyntaxKind4[SyntaxKind4["RestType"] = 188] = "RestType";
|
|
SyntaxKind4[SyntaxKind4["UnionType"] = 189] = "UnionType";
|
|
SyntaxKind4[SyntaxKind4["IntersectionType"] = 190] = "IntersectionType";
|
|
SyntaxKind4[SyntaxKind4["ConditionalType"] = 191] = "ConditionalType";
|
|
SyntaxKind4[SyntaxKind4["InferType"] = 192] = "InferType";
|
|
SyntaxKind4[SyntaxKind4["ParenthesizedType"] = 193] = "ParenthesizedType";
|
|
SyntaxKind4[SyntaxKind4["ThisType"] = 194] = "ThisType";
|
|
SyntaxKind4[SyntaxKind4["TypeOperator"] = 195] = "TypeOperator";
|
|
SyntaxKind4[SyntaxKind4["IndexedAccessType"] = 196] = "IndexedAccessType";
|
|
SyntaxKind4[SyntaxKind4["MappedType"] = 197] = "MappedType";
|
|
SyntaxKind4[SyntaxKind4["LiteralType"] = 198] = "LiteralType";
|
|
SyntaxKind4[SyntaxKind4["NamedTupleMember"] = 199] = "NamedTupleMember";
|
|
SyntaxKind4[SyntaxKind4["TemplateLiteralType"] = 200] = "TemplateLiteralType";
|
|
SyntaxKind4[SyntaxKind4["TemplateLiteralTypeSpan"] = 201] = "TemplateLiteralTypeSpan";
|
|
SyntaxKind4[SyntaxKind4["ImportType"] = 202] = "ImportType";
|
|
SyntaxKind4[SyntaxKind4["ObjectBindingPattern"] = 203] = "ObjectBindingPattern";
|
|
SyntaxKind4[SyntaxKind4["ArrayBindingPattern"] = 204] = "ArrayBindingPattern";
|
|
SyntaxKind4[SyntaxKind4["BindingElement"] = 205] = "BindingElement";
|
|
SyntaxKind4[SyntaxKind4["ArrayLiteralExpression"] = 206] = "ArrayLiteralExpression";
|
|
SyntaxKind4[SyntaxKind4["ObjectLiteralExpression"] = 207] = "ObjectLiteralExpression";
|
|
SyntaxKind4[SyntaxKind4["PropertyAccessExpression"] = 208] = "PropertyAccessExpression";
|
|
SyntaxKind4[SyntaxKind4["ElementAccessExpression"] = 209] = "ElementAccessExpression";
|
|
SyntaxKind4[SyntaxKind4["CallExpression"] = 210] = "CallExpression";
|
|
SyntaxKind4[SyntaxKind4["NewExpression"] = 211] = "NewExpression";
|
|
SyntaxKind4[SyntaxKind4["TaggedTemplateExpression"] = 212] = "TaggedTemplateExpression";
|
|
SyntaxKind4[SyntaxKind4["TypeAssertionExpression"] = 213] = "TypeAssertionExpression";
|
|
SyntaxKind4[SyntaxKind4["ParenthesizedExpression"] = 214] = "ParenthesizedExpression";
|
|
SyntaxKind4[SyntaxKind4["FunctionExpression"] = 215] = "FunctionExpression";
|
|
SyntaxKind4[SyntaxKind4["ArrowFunction"] = 216] = "ArrowFunction";
|
|
SyntaxKind4[SyntaxKind4["DeleteExpression"] = 217] = "DeleteExpression";
|
|
SyntaxKind4[SyntaxKind4["TypeOfExpression"] = 218] = "TypeOfExpression";
|
|
SyntaxKind4[SyntaxKind4["VoidExpression"] = 219] = "VoidExpression";
|
|
SyntaxKind4[SyntaxKind4["AwaitExpression"] = 220] = "AwaitExpression";
|
|
SyntaxKind4[SyntaxKind4["PrefixUnaryExpression"] = 221] = "PrefixUnaryExpression";
|
|
SyntaxKind4[SyntaxKind4["PostfixUnaryExpression"] = 222] = "PostfixUnaryExpression";
|
|
SyntaxKind4[SyntaxKind4["BinaryExpression"] = 223] = "BinaryExpression";
|
|
SyntaxKind4[SyntaxKind4["ConditionalExpression"] = 224] = "ConditionalExpression";
|
|
SyntaxKind4[SyntaxKind4["TemplateExpression"] = 225] = "TemplateExpression";
|
|
SyntaxKind4[SyntaxKind4["YieldExpression"] = 226] = "YieldExpression";
|
|
SyntaxKind4[SyntaxKind4["SpreadElement"] = 227] = "SpreadElement";
|
|
SyntaxKind4[SyntaxKind4["ClassExpression"] = 228] = "ClassExpression";
|
|
SyntaxKind4[SyntaxKind4["OmittedExpression"] = 229] = "OmittedExpression";
|
|
SyntaxKind4[SyntaxKind4["ExpressionWithTypeArguments"] = 230] = "ExpressionWithTypeArguments";
|
|
SyntaxKind4[SyntaxKind4["AsExpression"] = 231] = "AsExpression";
|
|
SyntaxKind4[SyntaxKind4["NonNullExpression"] = 232] = "NonNullExpression";
|
|
SyntaxKind4[SyntaxKind4["MetaProperty"] = 233] = "MetaProperty";
|
|
SyntaxKind4[SyntaxKind4["SyntheticExpression"] = 234] = "SyntheticExpression";
|
|
SyntaxKind4[SyntaxKind4["SatisfiesExpression"] = 235] = "SatisfiesExpression";
|
|
SyntaxKind4[SyntaxKind4["TemplateSpan"] = 236] = "TemplateSpan";
|
|
SyntaxKind4[SyntaxKind4["SemicolonClassElement"] = 237] = "SemicolonClassElement";
|
|
SyntaxKind4[SyntaxKind4["Block"] = 238] = "Block";
|
|
SyntaxKind4[SyntaxKind4["EmptyStatement"] = 239] = "EmptyStatement";
|
|
SyntaxKind4[SyntaxKind4["VariableStatement"] = 240] = "VariableStatement";
|
|
SyntaxKind4[SyntaxKind4["ExpressionStatement"] = 241] = "ExpressionStatement";
|
|
SyntaxKind4[SyntaxKind4["IfStatement"] = 242] = "IfStatement";
|
|
SyntaxKind4[SyntaxKind4["DoStatement"] = 243] = "DoStatement";
|
|
SyntaxKind4[SyntaxKind4["WhileStatement"] = 244] = "WhileStatement";
|
|
SyntaxKind4[SyntaxKind4["ForStatement"] = 245] = "ForStatement";
|
|
SyntaxKind4[SyntaxKind4["ForInStatement"] = 246] = "ForInStatement";
|
|
SyntaxKind4[SyntaxKind4["ForOfStatement"] = 247] = "ForOfStatement";
|
|
SyntaxKind4[SyntaxKind4["ContinueStatement"] = 248] = "ContinueStatement";
|
|
SyntaxKind4[SyntaxKind4["BreakStatement"] = 249] = "BreakStatement";
|
|
SyntaxKind4[SyntaxKind4["ReturnStatement"] = 250] = "ReturnStatement";
|
|
SyntaxKind4[SyntaxKind4["WithStatement"] = 251] = "WithStatement";
|
|
SyntaxKind4[SyntaxKind4["SwitchStatement"] = 252] = "SwitchStatement";
|
|
SyntaxKind4[SyntaxKind4["LabeledStatement"] = 253] = "LabeledStatement";
|
|
SyntaxKind4[SyntaxKind4["ThrowStatement"] = 254] = "ThrowStatement";
|
|
SyntaxKind4[SyntaxKind4["TryStatement"] = 255] = "TryStatement";
|
|
SyntaxKind4[SyntaxKind4["DebuggerStatement"] = 256] = "DebuggerStatement";
|
|
SyntaxKind4[SyntaxKind4["VariableDeclaration"] = 257] = "VariableDeclaration";
|
|
SyntaxKind4[SyntaxKind4["VariableDeclarationList"] = 258] = "VariableDeclarationList";
|
|
SyntaxKind4[SyntaxKind4["FunctionDeclaration"] = 259] = "FunctionDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ClassDeclaration"] = 260] = "ClassDeclaration";
|
|
SyntaxKind4[SyntaxKind4["InterfaceDeclaration"] = 261] = "InterfaceDeclaration";
|
|
SyntaxKind4[SyntaxKind4["TypeAliasDeclaration"] = 262] = "TypeAliasDeclaration";
|
|
SyntaxKind4[SyntaxKind4["EnumDeclaration"] = 263] = "EnumDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ModuleDeclaration"] = 264] = "ModuleDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ModuleBlock"] = 265] = "ModuleBlock";
|
|
SyntaxKind4[SyntaxKind4["CaseBlock"] = 266] = "CaseBlock";
|
|
SyntaxKind4[SyntaxKind4["NamespaceExportDeclaration"] = 267] = "NamespaceExportDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ImportEqualsDeclaration"] = 268] = "ImportEqualsDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ImportDeclaration"] = 269] = "ImportDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ImportClause"] = 270] = "ImportClause";
|
|
SyntaxKind4[SyntaxKind4["NamespaceImport"] = 271] = "NamespaceImport";
|
|
SyntaxKind4[SyntaxKind4["NamedImports"] = 272] = "NamedImports";
|
|
SyntaxKind4[SyntaxKind4["ImportSpecifier"] = 273] = "ImportSpecifier";
|
|
SyntaxKind4[SyntaxKind4["ExportAssignment"] = 274] = "ExportAssignment";
|
|
SyntaxKind4[SyntaxKind4["ExportDeclaration"] = 275] = "ExportDeclaration";
|
|
SyntaxKind4[SyntaxKind4["NamedExports"] = 276] = "NamedExports";
|
|
SyntaxKind4[SyntaxKind4["NamespaceExport"] = 277] = "NamespaceExport";
|
|
SyntaxKind4[SyntaxKind4["ExportSpecifier"] = 278] = "ExportSpecifier";
|
|
SyntaxKind4[SyntaxKind4["MissingDeclaration"] = 279] = "MissingDeclaration";
|
|
SyntaxKind4[SyntaxKind4["ExternalModuleReference"] = 280] = "ExternalModuleReference";
|
|
SyntaxKind4[SyntaxKind4["JsxElement"] = 281] = "JsxElement";
|
|
SyntaxKind4[SyntaxKind4["JsxSelfClosingElement"] = 282] = "JsxSelfClosingElement";
|
|
SyntaxKind4[SyntaxKind4["JsxOpeningElement"] = 283] = "JsxOpeningElement";
|
|
SyntaxKind4[SyntaxKind4["JsxClosingElement"] = 284] = "JsxClosingElement";
|
|
SyntaxKind4[SyntaxKind4["JsxFragment"] = 285] = "JsxFragment";
|
|
SyntaxKind4[SyntaxKind4["JsxOpeningFragment"] = 286] = "JsxOpeningFragment";
|
|
SyntaxKind4[SyntaxKind4["JsxClosingFragment"] = 287] = "JsxClosingFragment";
|
|
SyntaxKind4[SyntaxKind4["JsxAttribute"] = 288] = "JsxAttribute";
|
|
SyntaxKind4[SyntaxKind4["JsxAttributes"] = 289] = "JsxAttributes";
|
|
SyntaxKind4[SyntaxKind4["JsxSpreadAttribute"] = 290] = "JsxSpreadAttribute";
|
|
SyntaxKind4[SyntaxKind4["JsxExpression"] = 291] = "JsxExpression";
|
|
SyntaxKind4[SyntaxKind4["CaseClause"] = 292] = "CaseClause";
|
|
SyntaxKind4[SyntaxKind4["DefaultClause"] = 293] = "DefaultClause";
|
|
SyntaxKind4[SyntaxKind4["HeritageClause"] = 294] = "HeritageClause";
|
|
SyntaxKind4[SyntaxKind4["CatchClause"] = 295] = "CatchClause";
|
|
SyntaxKind4[SyntaxKind4["AssertClause"] = 296] = "AssertClause";
|
|
SyntaxKind4[SyntaxKind4["AssertEntry"] = 297] = "AssertEntry";
|
|
SyntaxKind4[SyntaxKind4["ImportTypeAssertionContainer"] = 298] = "ImportTypeAssertionContainer";
|
|
SyntaxKind4[SyntaxKind4["PropertyAssignment"] = 299] = "PropertyAssignment";
|
|
SyntaxKind4[SyntaxKind4["ShorthandPropertyAssignment"] = 300] = "ShorthandPropertyAssignment";
|
|
SyntaxKind4[SyntaxKind4["SpreadAssignment"] = 301] = "SpreadAssignment";
|
|
SyntaxKind4[SyntaxKind4["EnumMember"] = 302] = "EnumMember";
|
|
SyntaxKind4[SyntaxKind4["UnparsedPrologue"] = 303] = "UnparsedPrologue";
|
|
SyntaxKind4[SyntaxKind4["UnparsedPrepend"] = 304] = "UnparsedPrepend";
|
|
SyntaxKind4[SyntaxKind4["UnparsedText"] = 305] = "UnparsedText";
|
|
SyntaxKind4[SyntaxKind4["UnparsedInternalText"] = 306] = "UnparsedInternalText";
|
|
SyntaxKind4[SyntaxKind4["UnparsedSyntheticReference"] = 307] = "UnparsedSyntheticReference";
|
|
SyntaxKind4[SyntaxKind4["SourceFile"] = 308] = "SourceFile";
|
|
SyntaxKind4[SyntaxKind4["Bundle"] = 309] = "Bundle";
|
|
SyntaxKind4[SyntaxKind4["UnparsedSource"] = 310] = "UnparsedSource";
|
|
SyntaxKind4[SyntaxKind4["InputFiles"] = 311] = "InputFiles";
|
|
SyntaxKind4[SyntaxKind4["JSDocTypeExpression"] = 312] = "JSDocTypeExpression";
|
|
SyntaxKind4[SyntaxKind4["JSDocNameReference"] = 313] = "JSDocNameReference";
|
|
SyntaxKind4[SyntaxKind4["JSDocMemberName"] = 314] = "JSDocMemberName";
|
|
SyntaxKind4[SyntaxKind4["JSDocAllType"] = 315] = "JSDocAllType";
|
|
SyntaxKind4[SyntaxKind4["JSDocUnknownType"] = 316] = "JSDocUnknownType";
|
|
SyntaxKind4[SyntaxKind4["JSDocNullableType"] = 317] = "JSDocNullableType";
|
|
SyntaxKind4[SyntaxKind4["JSDocNonNullableType"] = 318] = "JSDocNonNullableType";
|
|
SyntaxKind4[SyntaxKind4["JSDocOptionalType"] = 319] = "JSDocOptionalType";
|
|
SyntaxKind4[SyntaxKind4["JSDocFunctionType"] = 320] = "JSDocFunctionType";
|
|
SyntaxKind4[SyntaxKind4["JSDocVariadicType"] = 321] = "JSDocVariadicType";
|
|
SyntaxKind4[SyntaxKind4["JSDocNamepathType"] = 322] = "JSDocNamepathType";
|
|
SyntaxKind4[SyntaxKind4["JSDoc"] = 323] = "JSDoc";
|
|
SyntaxKind4[SyntaxKind4["JSDocComment"] = 323 /* JSDoc */] = "JSDocComment";
|
|
SyntaxKind4[SyntaxKind4["JSDocText"] = 324] = "JSDocText";
|
|
SyntaxKind4[SyntaxKind4["JSDocTypeLiteral"] = 325] = "JSDocTypeLiteral";
|
|
SyntaxKind4[SyntaxKind4["JSDocSignature"] = 326] = "JSDocSignature";
|
|
SyntaxKind4[SyntaxKind4["JSDocLink"] = 327] = "JSDocLink";
|
|
SyntaxKind4[SyntaxKind4["JSDocLinkCode"] = 328] = "JSDocLinkCode";
|
|
SyntaxKind4[SyntaxKind4["JSDocLinkPlain"] = 329] = "JSDocLinkPlain";
|
|
SyntaxKind4[SyntaxKind4["JSDocTag"] = 330] = "JSDocTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocAugmentsTag"] = 331] = "JSDocAugmentsTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocImplementsTag"] = 332] = "JSDocImplementsTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocAuthorTag"] = 333] = "JSDocAuthorTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocDeprecatedTag"] = 334] = "JSDocDeprecatedTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocClassTag"] = 335] = "JSDocClassTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocPublicTag"] = 336] = "JSDocPublicTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocPrivateTag"] = 337] = "JSDocPrivateTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocProtectedTag"] = 338] = "JSDocProtectedTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocReadonlyTag"] = 339] = "JSDocReadonlyTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocOverrideTag"] = 340] = "JSDocOverrideTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocCallbackTag"] = 341] = "JSDocCallbackTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocEnumTag"] = 342] = "JSDocEnumTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocParameterTag"] = 343] = "JSDocParameterTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocReturnTag"] = 344] = "JSDocReturnTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocThisTag"] = 345] = "JSDocThisTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocTypeTag"] = 346] = "JSDocTypeTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocTemplateTag"] = 347] = "JSDocTemplateTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocTypedefTag"] = 348] = "JSDocTypedefTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocSeeTag"] = 349] = "JSDocSeeTag";
|
|
SyntaxKind4[SyntaxKind4["JSDocPropertyTag"] = 350] = "JSDocPropertyTag";
|
|
SyntaxKind4[SyntaxKind4["SyntaxList"] = 351] = "SyntaxList";
|
|
SyntaxKind4[SyntaxKind4["NotEmittedStatement"] = 352] = "NotEmittedStatement";
|
|
SyntaxKind4[SyntaxKind4["PartiallyEmittedExpression"] = 353] = "PartiallyEmittedExpression";
|
|
SyntaxKind4[SyntaxKind4["CommaListExpression"] = 354] = "CommaListExpression";
|
|
SyntaxKind4[SyntaxKind4["MergeDeclarationMarker"] = 355] = "MergeDeclarationMarker";
|
|
SyntaxKind4[SyntaxKind4["EndOfDeclarationMarker"] = 356] = "EndOfDeclarationMarker";
|
|
SyntaxKind4[SyntaxKind4["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression";
|
|
SyntaxKind4[SyntaxKind4["Count"] = 358] = "Count";
|
|
SyntaxKind4[SyntaxKind4["FirstAssignment"] = 63 /* EqualsToken */] = "FirstAssignment";
|
|
SyntaxKind4[SyntaxKind4["LastAssignment"] = 78 /* CaretEqualsToken */] = "LastAssignment";
|
|
SyntaxKind4[SyntaxKind4["FirstCompoundAssignment"] = 64 /* PlusEqualsToken */] = "FirstCompoundAssignment";
|
|
SyntaxKind4[SyntaxKind4["LastCompoundAssignment"] = 78 /* CaretEqualsToken */] = "LastCompoundAssignment";
|
|
SyntaxKind4[SyntaxKind4["FirstReservedWord"] = 81 /* BreakKeyword */] = "FirstReservedWord";
|
|
SyntaxKind4[SyntaxKind4["LastReservedWord"] = 116 /* WithKeyword */] = "LastReservedWord";
|
|
SyntaxKind4[SyntaxKind4["FirstKeyword"] = 81 /* BreakKeyword */] = "FirstKeyword";
|
|
SyntaxKind4[SyntaxKind4["LastKeyword"] = 162 /* OfKeyword */] = "LastKeyword";
|
|
SyntaxKind4[SyntaxKind4["FirstFutureReservedWord"] = 117 /* ImplementsKeyword */] = "FirstFutureReservedWord";
|
|
SyntaxKind4[SyntaxKind4["LastFutureReservedWord"] = 125 /* YieldKeyword */] = "LastFutureReservedWord";
|
|
SyntaxKind4[SyntaxKind4["FirstTypeNode"] = 179 /* TypePredicate */] = "FirstTypeNode";
|
|
SyntaxKind4[SyntaxKind4["LastTypeNode"] = 202 /* ImportType */] = "LastTypeNode";
|
|
SyntaxKind4[SyntaxKind4["FirstPunctuation"] = 18 /* OpenBraceToken */] = "FirstPunctuation";
|
|
SyntaxKind4[SyntaxKind4["LastPunctuation"] = 78 /* CaretEqualsToken */] = "LastPunctuation";
|
|
SyntaxKind4[SyntaxKind4["FirstToken"] = 0 /* Unknown */] = "FirstToken";
|
|
SyntaxKind4[SyntaxKind4["LastToken"] = 162 /* LastKeyword */] = "LastToken";
|
|
SyntaxKind4[SyntaxKind4["FirstTriviaToken"] = 2 /* SingleLineCommentTrivia */] = "FirstTriviaToken";
|
|
SyntaxKind4[SyntaxKind4["LastTriviaToken"] = 7 /* ConflictMarkerTrivia */] = "LastTriviaToken";
|
|
SyntaxKind4[SyntaxKind4["FirstLiteralToken"] = 8 /* NumericLiteral */] = "FirstLiteralToken";
|
|
SyntaxKind4[SyntaxKind4["LastLiteralToken"] = 14 /* NoSubstitutionTemplateLiteral */] = "LastLiteralToken";
|
|
SyntaxKind4[SyntaxKind4["FirstTemplateToken"] = 14 /* NoSubstitutionTemplateLiteral */] = "FirstTemplateToken";
|
|
SyntaxKind4[SyntaxKind4["LastTemplateToken"] = 17 /* TemplateTail */] = "LastTemplateToken";
|
|
SyntaxKind4[SyntaxKind4["FirstBinaryOperator"] = 29 /* LessThanToken */] = "FirstBinaryOperator";
|
|
SyntaxKind4[SyntaxKind4["LastBinaryOperator"] = 78 /* CaretEqualsToken */] = "LastBinaryOperator";
|
|
SyntaxKind4[SyntaxKind4["FirstStatement"] = 240 /* VariableStatement */] = "FirstStatement";
|
|
SyntaxKind4[SyntaxKind4["LastStatement"] = 256 /* DebuggerStatement */] = "LastStatement";
|
|
SyntaxKind4[SyntaxKind4["FirstNode"] = 163 /* QualifiedName */] = "FirstNode";
|
|
SyntaxKind4[SyntaxKind4["FirstJSDocNode"] = 312 /* JSDocTypeExpression */] = "FirstJSDocNode";
|
|
SyntaxKind4[SyntaxKind4["LastJSDocNode"] = 350 /* JSDocPropertyTag */] = "LastJSDocNode";
|
|
SyntaxKind4[SyntaxKind4["FirstJSDocTagNode"] = 330 /* JSDocTag */] = "FirstJSDocTagNode";
|
|
SyntaxKind4[SyntaxKind4["LastJSDocTagNode"] = 350 /* JSDocPropertyTag */] = "LastJSDocTagNode";
|
|
SyntaxKind4[SyntaxKind4["FirstContextualKeyword"] = 126 /* AbstractKeyword */] = "FirstContextualKeyword";
|
|
SyntaxKind4[SyntaxKind4["LastContextualKeyword"] = 162 /* OfKeyword */] = "LastContextualKeyword";
|
|
return SyntaxKind4;
|
|
})(SyntaxKind || {});
|
|
var NodeFlags = /* @__PURE__ */ ((NodeFlags3) => {
|
|
NodeFlags3[NodeFlags3["None"] = 0] = "None";
|
|
NodeFlags3[NodeFlags3["Let"] = 1] = "Let";
|
|
NodeFlags3[NodeFlags3["Const"] = 2] = "Const";
|
|
NodeFlags3[NodeFlags3["NestedNamespace"] = 4] = "NestedNamespace";
|
|
NodeFlags3[NodeFlags3["Synthesized"] = 8] = "Synthesized";
|
|
NodeFlags3[NodeFlags3["Namespace"] = 16] = "Namespace";
|
|
NodeFlags3[NodeFlags3["OptionalChain"] = 32] = "OptionalChain";
|
|
NodeFlags3[NodeFlags3["ExportContext"] = 64] = "ExportContext";
|
|
NodeFlags3[NodeFlags3["ContainsThis"] = 128] = "ContainsThis";
|
|
NodeFlags3[NodeFlags3["HasImplicitReturn"] = 256] = "HasImplicitReturn";
|
|
NodeFlags3[NodeFlags3["HasExplicitReturn"] = 512] = "HasExplicitReturn";
|
|
NodeFlags3[NodeFlags3["GlobalAugmentation"] = 1024] = "GlobalAugmentation";
|
|
NodeFlags3[NodeFlags3["HasAsyncFunctions"] = 2048] = "HasAsyncFunctions";
|
|
NodeFlags3[NodeFlags3["DisallowInContext"] = 4096] = "DisallowInContext";
|
|
NodeFlags3[NodeFlags3["YieldContext"] = 8192] = "YieldContext";
|
|
NodeFlags3[NodeFlags3["DecoratorContext"] = 16384] = "DecoratorContext";
|
|
NodeFlags3[NodeFlags3["AwaitContext"] = 32768] = "AwaitContext";
|
|
NodeFlags3[NodeFlags3["DisallowConditionalTypesContext"] = 65536] = "DisallowConditionalTypesContext";
|
|
NodeFlags3[NodeFlags3["ThisNodeHasError"] = 131072] = "ThisNodeHasError";
|
|
NodeFlags3[NodeFlags3["JavaScriptFile"] = 262144] = "JavaScriptFile";
|
|
NodeFlags3[NodeFlags3["ThisNodeOrAnySubNodesHasError"] = 524288] = "ThisNodeOrAnySubNodesHasError";
|
|
NodeFlags3[NodeFlags3["HasAggregatedChildData"] = 1048576] = "HasAggregatedChildData";
|
|
NodeFlags3[NodeFlags3["PossiblyContainsDynamicImport"] = 2097152] = "PossiblyContainsDynamicImport";
|
|
NodeFlags3[NodeFlags3["PossiblyContainsImportMeta"] = 4194304] = "PossiblyContainsImportMeta";
|
|
NodeFlags3[NodeFlags3["JSDoc"] = 8388608] = "JSDoc";
|
|
NodeFlags3[NodeFlags3["Ambient"] = 16777216] = "Ambient";
|
|
NodeFlags3[NodeFlags3["InWithStatement"] = 33554432] = "InWithStatement";
|
|
NodeFlags3[NodeFlags3["JsonFile"] = 67108864] = "JsonFile";
|
|
NodeFlags3[NodeFlags3["TypeCached"] = 134217728] = "TypeCached";
|
|
NodeFlags3[NodeFlags3["Deprecated"] = 268435456] = "Deprecated";
|
|
NodeFlags3[NodeFlags3["BlockScoped"] = 3] = "BlockScoped";
|
|
NodeFlags3[NodeFlags3["ReachabilityCheckFlags"] = 768] = "ReachabilityCheckFlags";
|
|
NodeFlags3[NodeFlags3["ReachabilityAndEmitFlags"] = 2816] = "ReachabilityAndEmitFlags";
|
|
NodeFlags3[NodeFlags3["ContextFlags"] = 50720768] = "ContextFlags";
|
|
NodeFlags3[NodeFlags3["TypeExcludesFlags"] = 40960] = "TypeExcludesFlags";
|
|
NodeFlags3[NodeFlags3["PermanentlySetIncrementalFlags"] = 6291456] = "PermanentlySetIncrementalFlags";
|
|
return NodeFlags3;
|
|
})(NodeFlags || {});
|
|
var ModifierFlags = /* @__PURE__ */ ((ModifierFlags3) => {
|
|
ModifierFlags3[ModifierFlags3["None"] = 0] = "None";
|
|
ModifierFlags3[ModifierFlags3["Export"] = 1] = "Export";
|
|
ModifierFlags3[ModifierFlags3["Ambient"] = 2] = "Ambient";
|
|
ModifierFlags3[ModifierFlags3["Public"] = 4] = "Public";
|
|
ModifierFlags3[ModifierFlags3["Private"] = 8] = "Private";
|
|
ModifierFlags3[ModifierFlags3["Protected"] = 16] = "Protected";
|
|
ModifierFlags3[ModifierFlags3["Static"] = 32] = "Static";
|
|
ModifierFlags3[ModifierFlags3["Readonly"] = 64] = "Readonly";
|
|
ModifierFlags3[ModifierFlags3["Accessor"] = 128] = "Accessor";
|
|
ModifierFlags3[ModifierFlags3["Abstract"] = 256] = "Abstract";
|
|
ModifierFlags3[ModifierFlags3["Async"] = 512] = "Async";
|
|
ModifierFlags3[ModifierFlags3["Default"] = 1024] = "Default";
|
|
ModifierFlags3[ModifierFlags3["Const"] = 2048] = "Const";
|
|
ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 4096] = "HasComputedJSDocModifiers";
|
|
ModifierFlags3[ModifierFlags3["Deprecated"] = 8192] = "Deprecated";
|
|
ModifierFlags3[ModifierFlags3["Override"] = 16384] = "Override";
|
|
ModifierFlags3[ModifierFlags3["In"] = 32768] = "In";
|
|
ModifierFlags3[ModifierFlags3["Out"] = 65536] = "Out";
|
|
ModifierFlags3[ModifierFlags3["Decorator"] = 131072] = "Decorator";
|
|
ModifierFlags3[ModifierFlags3["HasComputedFlags"] = 536870912] = "HasComputedFlags";
|
|
ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 28] = "AccessibilityModifier";
|
|
ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 16476] = "ParameterPropertyModifier";
|
|
ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier";
|
|
ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 117086] = "TypeScriptModifier";
|
|
ModifierFlags3[ModifierFlags3["ExportDefault"] = 1025] = "ExportDefault";
|
|
ModifierFlags3[ModifierFlags3["All"] = 258047] = "All";
|
|
ModifierFlags3[ModifierFlags3["Modifier"] = 126975] = "Modifier";
|
|
return ModifierFlags3;
|
|
})(ModifierFlags || {});
|
|
var RelationComparisonResult = /* @__PURE__ */ ((RelationComparisonResult3) => {
|
|
RelationComparisonResult3[RelationComparisonResult3["Succeeded"] = 1] = "Succeeded";
|
|
RelationComparisonResult3[RelationComparisonResult3["Failed"] = 2] = "Failed";
|
|
RelationComparisonResult3[RelationComparisonResult3["Reported"] = 4] = "Reported";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsUnmeasurable"] = 8] = "ReportsUnmeasurable";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsUnreliable"] = 16] = "ReportsUnreliable";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsMask"] = 24] = "ReportsMask";
|
|
return RelationComparisonResult3;
|
|
})(RelationComparisonResult || {});
|
|
var GeneratedIdentifierFlags = /* @__PURE__ */ ((GeneratedIdentifierFlags2) => {
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["None"] = 0] = "None";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["Auto"] = 1] = "Auto";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["Loop"] = 2] = "Loop";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["Unique"] = 3] = "Unique";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["Node"] = 4] = "Node";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["KindMask"] = 7] = "KindMask";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["ReservedInNestedScopes"] = 8] = "ReservedInNestedScopes";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["Optimistic"] = 16] = "Optimistic";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["FileLevel"] = 32] = "FileLevel";
|
|
GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["AllowNameSubstitution"] = 64] = "AllowNameSubstitution";
|
|
return GeneratedIdentifierFlags2;
|
|
})(GeneratedIdentifierFlags || {});
|
|
var FlowFlags = /* @__PURE__ */ ((FlowFlags2) => {
|
|
FlowFlags2[FlowFlags2["Unreachable"] = 1] = "Unreachable";
|
|
FlowFlags2[FlowFlags2["Start"] = 2] = "Start";
|
|
FlowFlags2[FlowFlags2["BranchLabel"] = 4] = "BranchLabel";
|
|
FlowFlags2[FlowFlags2["LoopLabel"] = 8] = "LoopLabel";
|
|
FlowFlags2[FlowFlags2["Assignment"] = 16] = "Assignment";
|
|
FlowFlags2[FlowFlags2["TrueCondition"] = 32] = "TrueCondition";
|
|
FlowFlags2[FlowFlags2["FalseCondition"] = 64] = "FalseCondition";
|
|
FlowFlags2[FlowFlags2["SwitchClause"] = 128] = "SwitchClause";
|
|
FlowFlags2[FlowFlags2["ArrayMutation"] = 256] = "ArrayMutation";
|
|
FlowFlags2[FlowFlags2["Call"] = 512] = "Call";
|
|
FlowFlags2[FlowFlags2["ReduceLabel"] = 1024] = "ReduceLabel";
|
|
FlowFlags2[FlowFlags2["Referenced"] = 2048] = "Referenced";
|
|
FlowFlags2[FlowFlags2["Shared"] = 4096] = "Shared";
|
|
FlowFlags2[FlowFlags2["Label"] = 12] = "Label";
|
|
FlowFlags2[FlowFlags2["Condition"] = 96] = "Condition";
|
|
return FlowFlags2;
|
|
})(FlowFlags || {});
|
|
var OperationCanceledException = class {
|
|
};
|
|
var FileIncludeKind = /* @__PURE__ */ ((FileIncludeKind2) => {
|
|
FileIncludeKind2[FileIncludeKind2["RootFile"] = 0] = "RootFile";
|
|
FileIncludeKind2[FileIncludeKind2["SourceFromProjectReference"] = 1] = "SourceFromProjectReference";
|
|
FileIncludeKind2[FileIncludeKind2["OutputFromProjectReference"] = 2] = "OutputFromProjectReference";
|
|
FileIncludeKind2[FileIncludeKind2["Import"] = 3] = "Import";
|
|
FileIncludeKind2[FileIncludeKind2["ReferenceFile"] = 4] = "ReferenceFile";
|
|
FileIncludeKind2[FileIncludeKind2["TypeReferenceDirective"] = 5] = "TypeReferenceDirective";
|
|
FileIncludeKind2[FileIncludeKind2["LibFile"] = 6] = "LibFile";
|
|
FileIncludeKind2[FileIncludeKind2["LibReferenceDirective"] = 7] = "LibReferenceDirective";
|
|
FileIncludeKind2[FileIncludeKind2["AutomaticTypeDirectiveFile"] = 8] = "AutomaticTypeDirectiveFile";
|
|
return FileIncludeKind2;
|
|
})(FileIncludeKind || {});
|
|
var SymbolFlags = /* @__PURE__ */ ((SymbolFlags2) => {
|
|
SymbolFlags2[SymbolFlags2["None"] = 0] = "None";
|
|
SymbolFlags2[SymbolFlags2["FunctionScopedVariable"] = 1] = "FunctionScopedVariable";
|
|
SymbolFlags2[SymbolFlags2["BlockScopedVariable"] = 2] = "BlockScopedVariable";
|
|
SymbolFlags2[SymbolFlags2["Property"] = 4] = "Property";
|
|
SymbolFlags2[SymbolFlags2["EnumMember"] = 8] = "EnumMember";
|
|
SymbolFlags2[SymbolFlags2["Function"] = 16] = "Function";
|
|
SymbolFlags2[SymbolFlags2["Class"] = 32] = "Class";
|
|
SymbolFlags2[SymbolFlags2["Interface"] = 64] = "Interface";
|
|
SymbolFlags2[SymbolFlags2["ConstEnum"] = 128] = "ConstEnum";
|
|
SymbolFlags2[SymbolFlags2["RegularEnum"] = 256] = "RegularEnum";
|
|
SymbolFlags2[SymbolFlags2["ValueModule"] = 512] = "ValueModule";
|
|
SymbolFlags2[SymbolFlags2["NamespaceModule"] = 1024] = "NamespaceModule";
|
|
SymbolFlags2[SymbolFlags2["TypeLiteral"] = 2048] = "TypeLiteral";
|
|
SymbolFlags2[SymbolFlags2["ObjectLiteral"] = 4096] = "ObjectLiteral";
|
|
SymbolFlags2[SymbolFlags2["Method"] = 8192] = "Method";
|
|
SymbolFlags2[SymbolFlags2["Constructor"] = 16384] = "Constructor";
|
|
SymbolFlags2[SymbolFlags2["GetAccessor"] = 32768] = "GetAccessor";
|
|
SymbolFlags2[SymbolFlags2["SetAccessor"] = 65536] = "SetAccessor";
|
|
SymbolFlags2[SymbolFlags2["Signature"] = 131072] = "Signature";
|
|
SymbolFlags2[SymbolFlags2["TypeParameter"] = 262144] = "TypeParameter";
|
|
SymbolFlags2[SymbolFlags2["TypeAlias"] = 524288] = "TypeAlias";
|
|
SymbolFlags2[SymbolFlags2["ExportValue"] = 1048576] = "ExportValue";
|
|
SymbolFlags2[SymbolFlags2["Alias"] = 2097152] = "Alias";
|
|
SymbolFlags2[SymbolFlags2["Prototype"] = 4194304] = "Prototype";
|
|
SymbolFlags2[SymbolFlags2["ExportStar"] = 8388608] = "ExportStar";
|
|
SymbolFlags2[SymbolFlags2["Optional"] = 16777216] = "Optional";
|
|
SymbolFlags2[SymbolFlags2["Transient"] = 33554432] = "Transient";
|
|
SymbolFlags2[SymbolFlags2["Assignment"] = 67108864] = "Assignment";
|
|
SymbolFlags2[SymbolFlags2["ModuleExports"] = 134217728] = "ModuleExports";
|
|
SymbolFlags2[SymbolFlags2["All"] = 67108863] = "All";
|
|
SymbolFlags2[SymbolFlags2["Enum"] = 384] = "Enum";
|
|
SymbolFlags2[SymbolFlags2["Variable"] = 3] = "Variable";
|
|
SymbolFlags2[SymbolFlags2["Value"] = 111551] = "Value";
|
|
SymbolFlags2[SymbolFlags2["Type"] = 788968] = "Type";
|
|
SymbolFlags2[SymbolFlags2["Namespace"] = 1920] = "Namespace";
|
|
SymbolFlags2[SymbolFlags2["Module"] = 1536] = "Module";
|
|
SymbolFlags2[SymbolFlags2["Accessor"] = 98304] = "Accessor";
|
|
SymbolFlags2[SymbolFlags2["FunctionScopedVariableExcludes"] = 111550] = "FunctionScopedVariableExcludes";
|
|
SymbolFlags2[SymbolFlags2["BlockScopedVariableExcludes"] = 111551 /* Value */] = "BlockScopedVariableExcludes";
|
|
SymbolFlags2[SymbolFlags2["ParameterExcludes"] = 111551 /* Value */] = "ParameterExcludes";
|
|
SymbolFlags2[SymbolFlags2["PropertyExcludes"] = 0 /* None */] = "PropertyExcludes";
|
|
SymbolFlags2[SymbolFlags2["EnumMemberExcludes"] = 900095] = "EnumMemberExcludes";
|
|
SymbolFlags2[SymbolFlags2["FunctionExcludes"] = 110991] = "FunctionExcludes";
|
|
SymbolFlags2[SymbolFlags2["ClassExcludes"] = 899503] = "ClassExcludes";
|
|
SymbolFlags2[SymbolFlags2["InterfaceExcludes"] = 788872] = "InterfaceExcludes";
|
|
SymbolFlags2[SymbolFlags2["RegularEnumExcludes"] = 899327] = "RegularEnumExcludes";
|
|
SymbolFlags2[SymbolFlags2["ConstEnumExcludes"] = 899967] = "ConstEnumExcludes";
|
|
SymbolFlags2[SymbolFlags2["ValueModuleExcludes"] = 110735] = "ValueModuleExcludes";
|
|
SymbolFlags2[SymbolFlags2["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes";
|
|
SymbolFlags2[SymbolFlags2["MethodExcludes"] = 103359] = "MethodExcludes";
|
|
SymbolFlags2[SymbolFlags2["GetAccessorExcludes"] = 46015] = "GetAccessorExcludes";
|
|
SymbolFlags2[SymbolFlags2["SetAccessorExcludes"] = 78783] = "SetAccessorExcludes";
|
|
SymbolFlags2[SymbolFlags2["AccessorExcludes"] = 13247] = "AccessorExcludes";
|
|
SymbolFlags2[SymbolFlags2["TypeParameterExcludes"] = 526824] = "TypeParameterExcludes";
|
|
SymbolFlags2[SymbolFlags2["TypeAliasExcludes"] = 788968 /* Type */] = "TypeAliasExcludes";
|
|
SymbolFlags2[SymbolFlags2["AliasExcludes"] = 2097152 /* Alias */] = "AliasExcludes";
|
|
SymbolFlags2[SymbolFlags2["ModuleMember"] = 2623475] = "ModuleMember";
|
|
SymbolFlags2[SymbolFlags2["ExportHasLocal"] = 944] = "ExportHasLocal";
|
|
SymbolFlags2[SymbolFlags2["BlockScoped"] = 418] = "BlockScoped";
|
|
SymbolFlags2[SymbolFlags2["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor";
|
|
SymbolFlags2[SymbolFlags2["ClassMember"] = 106500] = "ClassMember";
|
|
SymbolFlags2[SymbolFlags2["ExportSupportsDefaultModifier"] = 112] = "ExportSupportsDefaultModifier";
|
|
SymbolFlags2[SymbolFlags2["ExportDoesNotSupportDefaultModifier"] = -113] = "ExportDoesNotSupportDefaultModifier";
|
|
SymbolFlags2[SymbolFlags2["Classifiable"] = 2885600] = "Classifiable";
|
|
SymbolFlags2[SymbolFlags2["LateBindingContainer"] = 6256] = "LateBindingContainer";
|
|
return SymbolFlags2;
|
|
})(SymbolFlags || {});
|
|
var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
|
|
TypeFlags2[TypeFlags2["Any"] = 1] = "Any";
|
|
TypeFlags2[TypeFlags2["Unknown"] = 2] = "Unknown";
|
|
TypeFlags2[TypeFlags2["String"] = 4] = "String";
|
|
TypeFlags2[TypeFlags2["Number"] = 8] = "Number";
|
|
TypeFlags2[TypeFlags2["Boolean"] = 16] = "Boolean";
|
|
TypeFlags2[TypeFlags2["Enum"] = 32] = "Enum";
|
|
TypeFlags2[TypeFlags2["BigInt"] = 64] = "BigInt";
|
|
TypeFlags2[TypeFlags2["StringLiteral"] = 128] = "StringLiteral";
|
|
TypeFlags2[TypeFlags2["NumberLiteral"] = 256] = "NumberLiteral";
|
|
TypeFlags2[TypeFlags2["BooleanLiteral"] = 512] = "BooleanLiteral";
|
|
TypeFlags2[TypeFlags2["EnumLiteral"] = 1024] = "EnumLiteral";
|
|
TypeFlags2[TypeFlags2["BigIntLiteral"] = 2048] = "BigIntLiteral";
|
|
TypeFlags2[TypeFlags2["ESSymbol"] = 4096] = "ESSymbol";
|
|
TypeFlags2[TypeFlags2["UniqueESSymbol"] = 8192] = "UniqueESSymbol";
|
|
TypeFlags2[TypeFlags2["Void"] = 16384] = "Void";
|
|
TypeFlags2[TypeFlags2["Undefined"] = 32768] = "Undefined";
|
|
TypeFlags2[TypeFlags2["Null"] = 65536] = "Null";
|
|
TypeFlags2[TypeFlags2["Never"] = 131072] = "Never";
|
|
TypeFlags2[TypeFlags2["TypeParameter"] = 262144] = "TypeParameter";
|
|
TypeFlags2[TypeFlags2["Object"] = 524288] = "Object";
|
|
TypeFlags2[TypeFlags2["Union"] = 1048576] = "Union";
|
|
TypeFlags2[TypeFlags2["Intersection"] = 2097152] = "Intersection";
|
|
TypeFlags2[TypeFlags2["Index"] = 4194304] = "Index";
|
|
TypeFlags2[TypeFlags2["IndexedAccess"] = 8388608] = "IndexedAccess";
|
|
TypeFlags2[TypeFlags2["Conditional"] = 16777216] = "Conditional";
|
|
TypeFlags2[TypeFlags2["Substitution"] = 33554432] = "Substitution";
|
|
TypeFlags2[TypeFlags2["NonPrimitive"] = 67108864] = "NonPrimitive";
|
|
TypeFlags2[TypeFlags2["TemplateLiteral"] = 134217728] = "TemplateLiteral";
|
|
TypeFlags2[TypeFlags2["StringMapping"] = 268435456] = "StringMapping";
|
|
TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
|
|
TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
|
|
TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
|
|
TypeFlags2[TypeFlags2["Unit"] = 109440] = "Unit";
|
|
TypeFlags2[TypeFlags2["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
|
|
TypeFlags2[TypeFlags2["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique";
|
|
TypeFlags2[TypeFlags2["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
|
|
TypeFlags2[TypeFlags2["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
|
|
TypeFlags2[TypeFlags2["Intrinsic"] = 67359327] = "Intrinsic";
|
|
TypeFlags2[TypeFlags2["Primitive"] = 131068] = "Primitive";
|
|
TypeFlags2[TypeFlags2["StringLike"] = 402653316] = "StringLike";
|
|
TypeFlags2[TypeFlags2["NumberLike"] = 296] = "NumberLike";
|
|
TypeFlags2[TypeFlags2["BigIntLike"] = 2112] = "BigIntLike";
|
|
TypeFlags2[TypeFlags2["BooleanLike"] = 528] = "BooleanLike";
|
|
TypeFlags2[TypeFlags2["EnumLike"] = 1056] = "EnumLike";
|
|
TypeFlags2[TypeFlags2["ESSymbolLike"] = 12288] = "ESSymbolLike";
|
|
TypeFlags2[TypeFlags2["VoidLike"] = 49152] = "VoidLike";
|
|
TypeFlags2[TypeFlags2["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable";
|
|
TypeFlags2[TypeFlags2["DisjointDomains"] = 469892092] = "DisjointDomains";
|
|
TypeFlags2[TypeFlags2["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
|
|
TypeFlags2[TypeFlags2["StructuredType"] = 3670016] = "StructuredType";
|
|
TypeFlags2[TypeFlags2["TypeVariable"] = 8650752] = "TypeVariable";
|
|
TypeFlags2[TypeFlags2["InstantiableNonPrimitive"] = 58982400] = "InstantiableNonPrimitive";
|
|
TypeFlags2[TypeFlags2["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive";
|
|
TypeFlags2[TypeFlags2["Instantiable"] = 465829888] = "Instantiable";
|
|
TypeFlags2[TypeFlags2["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable";
|
|
TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
|
|
TypeFlags2[TypeFlags2["Simplifiable"] = 25165824] = "Simplifiable";
|
|
TypeFlags2[TypeFlags2["Singleton"] = 67358815] = "Singleton";
|
|
TypeFlags2[TypeFlags2["Narrowable"] = 536624127] = "Narrowable";
|
|
TypeFlags2[TypeFlags2["IncludesMask"] = 205258751] = "IncludesMask";
|
|
TypeFlags2[TypeFlags2["IncludesMissingType"] = 262144 /* TypeParameter */] = "IncludesMissingType";
|
|
TypeFlags2[TypeFlags2["IncludesNonWideningType"] = 4194304 /* Index */] = "IncludesNonWideningType";
|
|
TypeFlags2[TypeFlags2["IncludesWildcard"] = 8388608 /* IndexedAccess */] = "IncludesWildcard";
|
|
TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
|
|
TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
|
|
TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion";
|
|
return TypeFlags2;
|
|
})(TypeFlags || {});
|
|
var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
|
|
ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
|
|
ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
|
|
ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
|
|
ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
|
|
ObjectFlags3[ObjectFlags3["Tuple"] = 8] = "Tuple";
|
|
ObjectFlags3[ObjectFlags3["Anonymous"] = 16] = "Anonymous";
|
|
ObjectFlags3[ObjectFlags3["Mapped"] = 32] = "Mapped";
|
|
ObjectFlags3[ObjectFlags3["Instantiated"] = 64] = "Instantiated";
|
|
ObjectFlags3[ObjectFlags3["ObjectLiteral"] = 128] = "ObjectLiteral";
|
|
ObjectFlags3[ObjectFlags3["EvolvingArray"] = 256] = "EvolvingArray";
|
|
ObjectFlags3[ObjectFlags3["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties";
|
|
ObjectFlags3[ObjectFlags3["ReverseMapped"] = 1024] = "ReverseMapped";
|
|
ObjectFlags3[ObjectFlags3["JsxAttributes"] = 2048] = "JsxAttributes";
|
|
ObjectFlags3[ObjectFlags3["JSLiteral"] = 4096] = "JSLiteral";
|
|
ObjectFlags3[ObjectFlags3["FreshLiteral"] = 8192] = "FreshLiteral";
|
|
ObjectFlags3[ObjectFlags3["ArrayLiteral"] = 16384] = "ArrayLiteral";
|
|
ObjectFlags3[ObjectFlags3["PrimitiveUnion"] = 32768] = "PrimitiveUnion";
|
|
ObjectFlags3[ObjectFlags3["ContainsWideningType"] = 65536] = "ContainsWideningType";
|
|
ObjectFlags3[ObjectFlags3["ContainsObjectOrArrayLiteral"] = 131072] = "ContainsObjectOrArrayLiteral";
|
|
ObjectFlags3[ObjectFlags3["NonInferrableType"] = 262144] = "NonInferrableType";
|
|
ObjectFlags3[ObjectFlags3["CouldContainTypeVariablesComputed"] = 524288] = "CouldContainTypeVariablesComputed";
|
|
ObjectFlags3[ObjectFlags3["CouldContainTypeVariables"] = 1048576] = "CouldContainTypeVariables";
|
|
ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
|
|
ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
|
|
ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
|
|
ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
|
|
ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
|
|
ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
|
|
ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
|
|
ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
|
|
ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
|
|
ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
|
|
ObjectFlags3[ObjectFlags3["IsGenericTypeComputed"] = 2097152] = "IsGenericTypeComputed";
|
|
ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
|
|
ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
|
|
ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
|
|
ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
|
|
ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
|
|
ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
|
|
ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
|
|
ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 33554432] = "IsNeverIntersection";
|
|
return ObjectFlags3;
|
|
})(ObjectFlags || {});
|
|
var SignatureFlags = /* @__PURE__ */ ((SignatureFlags4) => {
|
|
SignatureFlags4[SignatureFlags4["None"] = 0] = "None";
|
|
SignatureFlags4[SignatureFlags4["HasRestParameter"] = 1] = "HasRestParameter";
|
|
SignatureFlags4[SignatureFlags4["HasLiteralTypes"] = 2] = "HasLiteralTypes";
|
|
SignatureFlags4[SignatureFlags4["Abstract"] = 4] = "Abstract";
|
|
SignatureFlags4[SignatureFlags4["IsInnerCallChain"] = 8] = "IsInnerCallChain";
|
|
SignatureFlags4[SignatureFlags4["IsOuterCallChain"] = 16] = "IsOuterCallChain";
|
|
SignatureFlags4[SignatureFlags4["IsUntypedSignatureInJSFile"] = 32] = "IsUntypedSignatureInJSFile";
|
|
SignatureFlags4[SignatureFlags4["PropagatingFlags"] = 39] = "PropagatingFlags";
|
|
SignatureFlags4[SignatureFlags4["CallChainFlags"] = 24] = "CallChainFlags";
|
|
return SignatureFlags4;
|
|
})(SignatureFlags || {});
|
|
var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
|
|
DiagnosticCategory2[DiagnosticCategory2["Warning"] = 0] = "Warning";
|
|
DiagnosticCategory2[DiagnosticCategory2["Error"] = 1] = "Error";
|
|
DiagnosticCategory2[DiagnosticCategory2["Suggestion"] = 2] = "Suggestion";
|
|
DiagnosticCategory2[DiagnosticCategory2["Message"] = 3] = "Message";
|
|
return DiagnosticCategory2;
|
|
})(DiagnosticCategory || {});
|
|
function diagnosticCategoryName(d, lowerCase = true) {
|
|
const name = DiagnosticCategory[d.category];
|
|
return lowerCase ? name.toLowerCase() : name;
|
|
}
|
|
var ModuleResolutionKind = /* @__PURE__ */ ((ModuleResolutionKind2) => {
|
|
ModuleResolutionKind2[ModuleResolutionKind2["Classic"] = 1] = "Classic";
|
|
ModuleResolutionKind2[ModuleResolutionKind2["NodeJs"] = 2] = "NodeJs";
|
|
ModuleResolutionKind2[ModuleResolutionKind2["Node16"] = 3] = "Node16";
|
|
ModuleResolutionKind2[ModuleResolutionKind2["NodeNext"] = 99] = "NodeNext";
|
|
return ModuleResolutionKind2;
|
|
})(ModuleResolutionKind || {});
|
|
var ModuleKind = /* @__PURE__ */ ((ModuleKind2) => {
|
|
ModuleKind2[ModuleKind2["None"] = 0] = "None";
|
|
ModuleKind2[ModuleKind2["CommonJS"] = 1] = "CommonJS";
|
|
ModuleKind2[ModuleKind2["AMD"] = 2] = "AMD";
|
|
ModuleKind2[ModuleKind2["UMD"] = 3] = "UMD";
|
|
ModuleKind2[ModuleKind2["System"] = 4] = "System";
|
|
ModuleKind2[ModuleKind2["ES2015"] = 5] = "ES2015";
|
|
ModuleKind2[ModuleKind2["ES2020"] = 6] = "ES2020";
|
|
ModuleKind2[ModuleKind2["ES2022"] = 7] = "ES2022";
|
|
ModuleKind2[ModuleKind2["ESNext"] = 99] = "ESNext";
|
|
ModuleKind2[ModuleKind2["Node16"] = 100] = "Node16";
|
|
ModuleKind2[ModuleKind2["NodeNext"] = 199] = "NodeNext";
|
|
return ModuleKind2;
|
|
})(ModuleKind || {});
|
|
var TransformFlags = /* @__PURE__ */ ((TransformFlags3) => {
|
|
TransformFlags3[TransformFlags3["None"] = 0] = "None";
|
|
TransformFlags3[TransformFlags3["ContainsTypeScript"] = 1] = "ContainsTypeScript";
|
|
TransformFlags3[TransformFlags3["ContainsJsx"] = 2] = "ContainsJsx";
|
|
TransformFlags3[TransformFlags3["ContainsESNext"] = 4] = "ContainsESNext";
|
|
TransformFlags3[TransformFlags3["ContainsES2022"] = 8] = "ContainsES2022";
|
|
TransformFlags3[TransformFlags3["ContainsES2021"] = 16] = "ContainsES2021";
|
|
TransformFlags3[TransformFlags3["ContainsES2020"] = 32] = "ContainsES2020";
|
|
TransformFlags3[TransformFlags3["ContainsES2019"] = 64] = "ContainsES2019";
|
|
TransformFlags3[TransformFlags3["ContainsES2018"] = 128] = "ContainsES2018";
|
|
TransformFlags3[TransformFlags3["ContainsES2017"] = 256] = "ContainsES2017";
|
|
TransformFlags3[TransformFlags3["ContainsES2016"] = 512] = "ContainsES2016";
|
|
TransformFlags3[TransformFlags3["ContainsES2015"] = 1024] = "ContainsES2015";
|
|
TransformFlags3[TransformFlags3["ContainsGenerator"] = 2048] = "ContainsGenerator";
|
|
TransformFlags3[TransformFlags3["ContainsDestructuringAssignment"] = 4096] = "ContainsDestructuringAssignment";
|
|
TransformFlags3[TransformFlags3["ContainsTypeScriptClassSyntax"] = 8192] = "ContainsTypeScriptClassSyntax";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalThis"] = 16384] = "ContainsLexicalThis";
|
|
TransformFlags3[TransformFlags3["ContainsRestOrSpread"] = 32768] = "ContainsRestOrSpread";
|
|
TransformFlags3[TransformFlags3["ContainsObjectRestOrSpread"] = 65536] = "ContainsObjectRestOrSpread";
|
|
TransformFlags3[TransformFlags3["ContainsComputedPropertyName"] = 131072] = "ContainsComputedPropertyName";
|
|
TransformFlags3[TransformFlags3["ContainsBlockScopedBinding"] = 262144] = "ContainsBlockScopedBinding";
|
|
TransformFlags3[TransformFlags3["ContainsBindingPattern"] = 524288] = "ContainsBindingPattern";
|
|
TransformFlags3[TransformFlags3["ContainsYield"] = 1048576] = "ContainsYield";
|
|
TransformFlags3[TransformFlags3["ContainsAwait"] = 2097152] = "ContainsAwait";
|
|
TransformFlags3[TransformFlags3["ContainsHoistedDeclarationOrCompletion"] = 4194304] = "ContainsHoistedDeclarationOrCompletion";
|
|
TransformFlags3[TransformFlags3["ContainsDynamicImport"] = 8388608] = "ContainsDynamicImport";
|
|
TransformFlags3[TransformFlags3["ContainsClassFields"] = 16777216] = "ContainsClassFields";
|
|
TransformFlags3[TransformFlags3["ContainsDecorators"] = 33554432] = "ContainsDecorators";
|
|
TransformFlags3[TransformFlags3["ContainsPossibleTopLevelAwait"] = 67108864] = "ContainsPossibleTopLevelAwait";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalSuper"] = 134217728] = "ContainsLexicalSuper";
|
|
TransformFlags3[TransformFlags3["ContainsUpdateExpressionForIdentifier"] = 268435456] = "ContainsUpdateExpressionForIdentifier";
|
|
TransformFlags3[TransformFlags3["ContainsPrivateIdentifierInExpression"] = 536870912] = "ContainsPrivateIdentifierInExpression";
|
|
TransformFlags3[TransformFlags3["HasComputedFlags"] = -2147483648] = "HasComputedFlags";
|
|
TransformFlags3[TransformFlags3["AssertTypeScript"] = 1 /* ContainsTypeScript */] = "AssertTypeScript";
|
|
TransformFlags3[TransformFlags3["AssertJsx"] = 2 /* ContainsJsx */] = "AssertJsx";
|
|
TransformFlags3[TransformFlags3["AssertESNext"] = 4 /* ContainsESNext */] = "AssertESNext";
|
|
TransformFlags3[TransformFlags3["AssertES2022"] = 8 /* ContainsES2022 */] = "AssertES2022";
|
|
TransformFlags3[TransformFlags3["AssertES2021"] = 16 /* ContainsES2021 */] = "AssertES2021";
|
|
TransformFlags3[TransformFlags3["AssertES2020"] = 32 /* ContainsES2020 */] = "AssertES2020";
|
|
TransformFlags3[TransformFlags3["AssertES2019"] = 64 /* ContainsES2019 */] = "AssertES2019";
|
|
TransformFlags3[TransformFlags3["AssertES2018"] = 128 /* ContainsES2018 */] = "AssertES2018";
|
|
TransformFlags3[TransformFlags3["AssertES2017"] = 256 /* ContainsES2017 */] = "AssertES2017";
|
|
TransformFlags3[TransformFlags3["AssertES2016"] = 512 /* ContainsES2016 */] = "AssertES2016";
|
|
TransformFlags3[TransformFlags3["AssertES2015"] = 1024 /* ContainsES2015 */] = "AssertES2015";
|
|
TransformFlags3[TransformFlags3["AssertGenerator"] = 2048 /* ContainsGenerator */] = "AssertGenerator";
|
|
TransformFlags3[TransformFlags3["AssertDestructuringAssignment"] = 4096 /* ContainsDestructuringAssignment */] = "AssertDestructuringAssignment";
|
|
TransformFlags3[TransformFlags3["OuterExpressionExcludes"] = -2147483648 /* HasComputedFlags */] = "OuterExpressionExcludes";
|
|
TransformFlags3[TransformFlags3["PropertyAccessExcludes"] = -2147483648 /* OuterExpressionExcludes */] = "PropertyAccessExcludes";
|
|
TransformFlags3[TransformFlags3["NodeExcludes"] = -2147483648 /* PropertyAccessExcludes */] = "NodeExcludes";
|
|
TransformFlags3[TransformFlags3["ArrowFunctionExcludes"] = -2072174592] = "ArrowFunctionExcludes";
|
|
TransformFlags3[TransformFlags3["FunctionExcludes"] = -1937940480] = "FunctionExcludes";
|
|
TransformFlags3[TransformFlags3["ConstructorExcludes"] = -1937948672] = "ConstructorExcludes";
|
|
TransformFlags3[TransformFlags3["MethodOrAccessorExcludes"] = -2005057536] = "MethodOrAccessorExcludes";
|
|
TransformFlags3[TransformFlags3["PropertyExcludes"] = -2013249536] = "PropertyExcludes";
|
|
TransformFlags3[TransformFlags3["ClassExcludes"] = -2147344384] = "ClassExcludes";
|
|
TransformFlags3[TransformFlags3["ModuleExcludes"] = -1941676032] = "ModuleExcludes";
|
|
TransformFlags3[TransformFlags3["TypeExcludes"] = -2] = "TypeExcludes";
|
|
TransformFlags3[TransformFlags3["ObjectLiteralExcludes"] = -2147278848] = "ObjectLiteralExcludes";
|
|
TransformFlags3[TransformFlags3["ArrayLiteralOrCallOrNewExcludes"] = -2147450880] = "ArrayLiteralOrCallOrNewExcludes";
|
|
TransformFlags3[TransformFlags3["VariableDeclarationListExcludes"] = -2146893824] = "VariableDeclarationListExcludes";
|
|
TransformFlags3[TransformFlags3["ParameterExcludes"] = -2147483648 /* NodeExcludes */] = "ParameterExcludes";
|
|
TransformFlags3[TransformFlags3["CatchClauseExcludes"] = -2147418112] = "CatchClauseExcludes";
|
|
TransformFlags3[TransformFlags3["BindingPatternExcludes"] = -2147450880] = "BindingPatternExcludes";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalThisOrSuper"] = 134234112] = "ContainsLexicalThisOrSuper";
|
|
TransformFlags3[TransformFlags3["PropertyNamePropagatingFlags"] = 134234112] = "PropertyNamePropagatingFlags";
|
|
return TransformFlags3;
|
|
})(TransformFlags || {});
|
|
var SnippetKind = /* @__PURE__ */ ((SnippetKind3) => {
|
|
SnippetKind3[SnippetKind3["TabStop"] = 0] = "TabStop";
|
|
SnippetKind3[SnippetKind3["Placeholder"] = 1] = "Placeholder";
|
|
SnippetKind3[SnippetKind3["Choice"] = 2] = "Choice";
|
|
SnippetKind3[SnippetKind3["Variable"] = 3] = "Variable";
|
|
return SnippetKind3;
|
|
})(SnippetKind || {});
|
|
var EmitFlags = /* @__PURE__ */ ((EmitFlags3) => {
|
|
EmitFlags3[EmitFlags3["None"] = 0] = "None";
|
|
EmitFlags3[EmitFlags3["SingleLine"] = 1] = "SingleLine";
|
|
EmitFlags3[EmitFlags3["MultiLine"] = 2] = "MultiLine";
|
|
EmitFlags3[EmitFlags3["AdviseOnEmitNode"] = 4] = "AdviseOnEmitNode";
|
|
EmitFlags3[EmitFlags3["NoSubstitution"] = 8] = "NoSubstitution";
|
|
EmitFlags3[EmitFlags3["CapturesThis"] = 16] = "CapturesThis";
|
|
EmitFlags3[EmitFlags3["NoLeadingSourceMap"] = 32] = "NoLeadingSourceMap";
|
|
EmitFlags3[EmitFlags3["NoTrailingSourceMap"] = 64] = "NoTrailingSourceMap";
|
|
EmitFlags3[EmitFlags3["NoSourceMap"] = 96] = "NoSourceMap";
|
|
EmitFlags3[EmitFlags3["NoNestedSourceMaps"] = 128] = "NoNestedSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenLeadingSourceMaps"] = 256] = "NoTokenLeadingSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenTrailingSourceMaps"] = 512] = "NoTokenTrailingSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenSourceMaps"] = 768] = "NoTokenSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoLeadingComments"] = 1024] = "NoLeadingComments";
|
|
EmitFlags3[EmitFlags3["NoTrailingComments"] = 2048] = "NoTrailingComments";
|
|
EmitFlags3[EmitFlags3["NoComments"] = 3072] = "NoComments";
|
|
EmitFlags3[EmitFlags3["NoNestedComments"] = 4096] = "NoNestedComments";
|
|
EmitFlags3[EmitFlags3["HelperName"] = 8192] = "HelperName";
|
|
EmitFlags3[EmitFlags3["ExportName"] = 16384] = "ExportName";
|
|
EmitFlags3[EmitFlags3["LocalName"] = 32768] = "LocalName";
|
|
EmitFlags3[EmitFlags3["InternalName"] = 65536] = "InternalName";
|
|
EmitFlags3[EmitFlags3["Indented"] = 131072] = "Indented";
|
|
EmitFlags3[EmitFlags3["NoIndentation"] = 262144] = "NoIndentation";
|
|
EmitFlags3[EmitFlags3["AsyncFunctionBody"] = 524288] = "AsyncFunctionBody";
|
|
EmitFlags3[EmitFlags3["ReuseTempVariableScope"] = 1048576] = "ReuseTempVariableScope";
|
|
EmitFlags3[EmitFlags3["CustomPrologue"] = 2097152] = "CustomPrologue";
|
|
EmitFlags3[EmitFlags3["NoHoisting"] = 4194304] = "NoHoisting";
|
|
EmitFlags3[EmitFlags3["HasEndOfDeclarationMarker"] = 8388608] = "HasEndOfDeclarationMarker";
|
|
EmitFlags3[EmitFlags3["Iterator"] = 16777216] = "Iterator";
|
|
EmitFlags3[EmitFlags3["NoAsciiEscaping"] = 33554432] = "NoAsciiEscaping";
|
|
EmitFlags3[EmitFlags3["TypeScriptClassWrapper"] = 67108864] = "TypeScriptClassWrapper";
|
|
EmitFlags3[EmitFlags3["NeverApplyImportHelper"] = 134217728] = "NeverApplyImportHelper";
|
|
EmitFlags3[EmitFlags3["IgnoreSourceNewlines"] = 268435456] = "IgnoreSourceNewlines";
|
|
EmitFlags3[EmitFlags3["Immutable"] = 536870912] = "Immutable";
|
|
EmitFlags3[EmitFlags3["IndirectCall"] = 1073741824] = "IndirectCall";
|
|
return EmitFlags3;
|
|
})(EmitFlags || {});
|
|
var 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 /* TripleSlashXML */
|
|
},
|
|
"amd-dependency": {
|
|
args: [{ name: "path" }, { name: "name", optional: true }],
|
|
kind: 1 /* TripleSlashXML */
|
|
},
|
|
"amd-module": {
|
|
args: [{ name: "name" }],
|
|
kind: 1 /* TripleSlashXML */
|
|
},
|
|
"ts-check": {
|
|
kind: 2 /* SingleLine */
|
|
},
|
|
"ts-nocheck": {
|
|
kind: 2 /* SingleLine */
|
|
},
|
|
"jsx": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsxfrag": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsximportsource": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsxruntime": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
}
|
|
};
|
|
|
|
// src/compiler/sys.ts
|
|
function generateDjb2Hash(data) {
|
|
let acc = 5381;
|
|
for (let i = 0; i < data.length; i++) {
|
|
acc = (acc << 5) + acc + data.charCodeAt(i);
|
|
}
|
|
return acc.toString();
|
|
}
|
|
var PollingInterval = /* @__PURE__ */ ((PollingInterval3) => {
|
|
PollingInterval3[PollingInterval3["High"] = 2e3] = "High";
|
|
PollingInterval3[PollingInterval3["Medium"] = 500] = "Medium";
|
|
PollingInterval3[PollingInterval3["Low"] = 250] = "Low";
|
|
return PollingInterval3;
|
|
})(PollingInterval || {});
|
|
var missingFileModifiedTime = new Date(0);
|
|
function getModifiedTime(host, fileName) {
|
|
return host.getModifiedTime(fileName) || missingFileModifiedTime;
|
|
}
|
|
function createPollingIntervalBasedLevels(levels) {
|
|
return {
|
|
[250 /* Low */]: levels.Low,
|
|
[500 /* Medium */]: levels.Medium,
|
|
[2e3 /* High */]: levels.High
|
|
};
|
|
}
|
|
var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 };
|
|
var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels);
|
|
var unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
|
|
function setCustomPollingValues(system) {
|
|
if (!system.getEnvironmentVariable) {
|
|
return;
|
|
}
|
|
const pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval);
|
|
pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;
|
|
unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || unchangedPollThresholds;
|
|
function getLevel(envVar, level) {
|
|
return system.getEnvironmentVariable(`${envVar}_${level.toUpperCase()}`);
|
|
}
|
|
function getCustomLevels(baseVariable) {
|
|
let customLevels;
|
|
setCustomLevel("Low");
|
|
setCustomLevel("Medium");
|
|
setCustomLevel("High");
|
|
return customLevels;
|
|
function setCustomLevel(level) {
|
|
const customLevel = getLevel(baseVariable, level);
|
|
if (customLevel) {
|
|
(customLevels || (customLevels = {}))[level] = Number(customLevel);
|
|
}
|
|
}
|
|
}
|
|
function setCustomLevels(baseVariable, levels) {
|
|
const 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) {
|
|
const customLevels = getCustomLevels(baseVariable);
|
|
return (pollingIntervalChanged || customLevels) && createPollingIntervalBasedLevels(customLevels ? { ...defaultLevels, ...customLevels } : defaultLevels);
|
|
}
|
|
}
|
|
function pollWatchedFileQueue(host, queue, pollIndex, chunkSize, callbackOnWatchFileStat) {
|
|
let definedValueCopyToIndex = pollIndex;
|
|
for (let canVisit = queue.length; chunkSize && canVisit; nextPollIndex(), canVisit--) {
|
|
const watchedFile = queue[pollIndex];
|
|
if (!watchedFile) {
|
|
continue;
|
|
} else if (watchedFile.isClosed) {
|
|
queue[pollIndex] = void 0;
|
|
continue;
|
|
}
|
|
chunkSize--;
|
|
const fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(host, watchedFile.fileName));
|
|
if (watchedFile.isClosed) {
|
|
queue[pollIndex] = void 0;
|
|
continue;
|
|
}
|
|
callbackOnWatchFileStat == null ? void 0 : callbackOnWatchFileStat(watchedFile, pollIndex, fileChanged);
|
|
if (queue[pollIndex]) {
|
|
if (definedValueCopyToIndex < pollIndex) {
|
|
queue[definedValueCopyToIndex] = watchedFile;
|
|
queue[pollIndex] = void 0;
|
|
}
|
|
definedValueCopyToIndex++;
|
|
}
|
|
}
|
|
return pollIndex;
|
|
function nextPollIndex() {
|
|
pollIndex++;
|
|
if (pollIndex === queue.length) {
|
|
if (definedValueCopyToIndex < pollIndex) {
|
|
queue.length = definedValueCopyToIndex;
|
|
}
|
|
pollIndex = 0;
|
|
definedValueCopyToIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
function createDynamicPriorityPollingWatchFile(host) {
|
|
const watchedFiles = [];
|
|
const changedFilesInLastPoll = [];
|
|
const lowPollingIntervalQueue = createPollingIntervalQueue(250 /* Low */);
|
|
const mediumPollingIntervalQueue = createPollingIntervalQueue(500 /* Medium */);
|
|
const highPollingIntervalQueue = createPollingIntervalQueue(2e3 /* High */);
|
|
return watchFile2;
|
|
function watchFile2(fileName, callback, defaultPollingInterval) {
|
|
const file = {
|
|
fileName,
|
|
callback,
|
|
unchangedPolls: 0,
|
|
mtime: getModifiedTime(host, fileName)
|
|
};
|
|
watchedFiles.push(file);
|
|
addToPollingIntervalQueue(file, defaultPollingInterval);
|
|
return {
|
|
close: () => {
|
|
file.isClosed = true;
|
|
unorderedRemoveItem(watchedFiles, file);
|
|
}
|
|
};
|
|
}
|
|
function createPollingIntervalQueue(pollingInterval) {
|
|
const 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]);
|
|
if (queue.length) {
|
|
scheduleNextPoll(queue.pollingInterval);
|
|
} else {
|
|
Debug.assert(queue.pollIndex === 0);
|
|
queue.pollScheduled = false;
|
|
}
|
|
}
|
|
function pollLowPollingIntervalQueue(queue) {
|
|
pollQueue(changedFilesInLastPoll, 250 /* Low */, 0, changedFilesInLastPoll.length);
|
|
pollPollingIntervalQueue(queue);
|
|
if (!queue.pollScheduled && changedFilesInLastPoll.length) {
|
|
scheduleNextPoll(250 /* Low */);
|
|
}
|
|
}
|
|
function pollQueue(queue, pollingInterval, pollIndex, chunkSize) {
|
|
return pollWatchedFileQueue(
|
|
host,
|
|
queue,
|
|
pollIndex,
|
|
chunkSize,
|
|
onWatchFileStat
|
|
);
|
|
function onWatchFileStat(watchedFile, pollIndex2, fileChanged) {
|
|
if (fileChanged) {
|
|
watchedFile.unchangedPolls = 0;
|
|
if (queue !== changedFilesInLastPoll) {
|
|
queue[pollIndex2] = void 0;
|
|
addChangedFileToLowPollingIntervalQueue(watchedFile);
|
|
}
|
|
} else if (watchedFile.unchangedPolls !== unchangedPollThresholds[pollingInterval]) {
|
|
watchedFile.unchangedPolls++;
|
|
} else if (queue === changedFilesInLastPoll) {
|
|
watchedFile.unchangedPolls = 1;
|
|
queue[pollIndex2] = void 0;
|
|
addToPollingIntervalQueue(watchedFile, 250 /* Low */);
|
|
} else if (pollingInterval !== 2e3 /* High */) {
|
|
watchedFile.unchangedPolls++;
|
|
queue[pollIndex2] = void 0;
|
|
addToPollingIntervalQueue(watchedFile, pollingInterval === 250 /* Low */ ? 500 /* Medium */ : 2e3 /* High */);
|
|
}
|
|
}
|
|
}
|
|
function pollingIntervalQueue(pollingInterval) {
|
|
switch (pollingInterval) {
|
|
case 250 /* Low */:
|
|
return lowPollingIntervalQueue;
|
|
case 500 /* Medium */:
|
|
return mediumPollingIntervalQueue;
|
|
case 2e3 /* High */:
|
|
return highPollingIntervalQueue;
|
|
}
|
|
}
|
|
function addToPollingIntervalQueue(file, pollingInterval) {
|
|
pollingIntervalQueue(pollingInterval).push(file);
|
|
scheduleNextPollIfNotAlreadyScheduled(pollingInterval);
|
|
}
|
|
function addChangedFileToLowPollingIntervalQueue(file) {
|
|
changedFilesInLastPoll.push(file);
|
|
scheduleNextPollIfNotAlreadyScheduled(250 /* Low */);
|
|
}
|
|
function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) {
|
|
if (!pollingIntervalQueue(pollingInterval).pollScheduled) {
|
|
scheduleNextPoll(pollingInterval);
|
|
}
|
|
}
|
|
function scheduleNextPoll(pollingInterval) {
|
|
pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === 250 /* Low */ ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval));
|
|
}
|
|
}
|
|
function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) {
|
|
const fileWatcherCallbacks = createMultiMap();
|
|
const dirWatchers = /* @__PURE__ */ new Map();
|
|
const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return nonPollingWatchFile;
|
|
function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
|
|
const filePath = toCanonicalName(fileName);
|
|
fileWatcherCallbacks.add(filePath, callback);
|
|
const dirPath = getDirectoryPath(filePath) || ".";
|
|
const watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);
|
|
watcher.referenceCount++;
|
|
return {
|
|
close: () => {
|
|
if (watcher.referenceCount === 1) {
|
|
watcher.close();
|
|
dirWatchers.delete(dirPath);
|
|
} else {
|
|
watcher.referenceCount--;
|
|
}
|
|
fileWatcherCallbacks.remove(filePath, callback);
|
|
}
|
|
};
|
|
}
|
|
function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
|
|
const watcher = fsWatch(
|
|
dirName,
|
|
FileSystemEntryKind.Directory,
|
|
(_eventName, relativeFileName, modifiedTime) => {
|
|
if (!isString(relativeFileName))
|
|
return;
|
|
const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);
|
|
const callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));
|
|
if (callbacks) {
|
|
for (const fileCallback of callbacks) {
|
|
fileCallback(fileName, 1 /* Changed */, modifiedTime);
|
|
}
|
|
}
|
|
},
|
|
false,
|
|
500 /* Medium */,
|
|
fallbackOptions
|
|
);
|
|
watcher.referenceCount = 0;
|
|
dirWatchers.set(dirPath, watcher);
|
|
return watcher;
|
|
}
|
|
}
|
|
function createFixedChunkSizePollingWatchFile(host) {
|
|
const watchedFiles = [];
|
|
let pollIndex = 0;
|
|
let pollScheduled;
|
|
return watchFile2;
|
|
function watchFile2(fileName, callback) {
|
|
const file = {
|
|
fileName,
|
|
callback,
|
|
mtime: getModifiedTime(host, fileName)
|
|
};
|
|
watchedFiles.push(file);
|
|
scheduleNextPoll();
|
|
return {
|
|
close: () => {
|
|
file.isClosed = true;
|
|
unorderedRemoveItem(watchedFiles, file);
|
|
}
|
|
};
|
|
}
|
|
function pollQueue() {
|
|
pollScheduled = void 0;
|
|
pollIndex = pollWatchedFileQueue(host, watchedFiles, pollIndex, pollingChunkSize[250 /* Low */]);
|
|
scheduleNextPoll();
|
|
}
|
|
function scheduleNextPoll() {
|
|
if (!watchedFiles.length || pollScheduled)
|
|
return;
|
|
pollScheduled = host.setTimeout(pollQueue, 2e3 /* High */);
|
|
}
|
|
}
|
|
function createSingleWatcherPerName(cache, useCaseSensitiveFileNames, name, callback, createWatcher) {
|
|
const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
const path = toCanonicalFileName(name);
|
|
const existing = cache.get(path);
|
|
if (existing) {
|
|
existing.callbacks.push(callback);
|
|
} else {
|
|
cache.set(path, {
|
|
watcher: createWatcher((param1, param2, param3) => {
|
|
var _a2;
|
|
return (_a2 = cache.get(path)) == null ? void 0 : _a2.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
|
|
}),
|
|
callbacks: [callback]
|
|
});
|
|
}
|
|
return {
|
|
close: () => {
|
|
const watcher = cache.get(path);
|
|
if (!watcher)
|
|
return;
|
|
if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length)
|
|
return;
|
|
cache.delete(path);
|
|
closeFileWatcherOf(watcher);
|
|
}
|
|
};
|
|
}
|
|
function onWatchedFileStat(watchedFile, modifiedTime) {
|
|
const oldTime = watchedFile.mtime.getTime();
|
|
const newTime = modifiedTime.getTime();
|
|
if (oldTime !== newTime) {
|
|
watchedFile.mtime = modifiedTime;
|
|
watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime), modifiedTime);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getFileWatcherEventKind(oldTime, newTime) {
|
|
return oldTime === 0 ? 0 /* Created */ : newTime === 0 ? 2 /* Deleted */ : 1 /* Changed */;
|
|
}
|
|
var ignoredPaths = ["/node_modules/.", "/.git", "/.#"];
|
|
var curSysLog = noop;
|
|
function sysLog(s) {
|
|
return curSysLog(s);
|
|
}
|
|
function setSysLog(logger) {
|
|
curSysLog = logger;
|
|
}
|
|
function createDirectoryWatcherSupportingRecursive({
|
|
watchDirectory,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
getAccessibleSortedChildDirectories,
|
|
fileSystemEntryExists,
|
|
realpath,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2
|
|
}) {
|
|
const cache = /* @__PURE__ */ new Map();
|
|
const callbackCache = createMultiMap();
|
|
const cacheToUpdateChildWatches = /* @__PURE__ */ new Map();
|
|
let timerToUpdateChildWatches;
|
|
const filePathComparer = getStringComparer(!useCaseSensitiveFileNames);
|
|
const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return (dirName, callback, recursive, options) => recursive ? createDirectoryWatcher(dirName, options, callback) : watchDirectory(dirName, callback, recursive, options);
|
|
function createDirectoryWatcher(dirName, options, callback) {
|
|
const dirPath = toCanonicalFilePath(dirName);
|
|
let directoryWatcher = cache.get(dirPath);
|
|
if (directoryWatcher) {
|
|
directoryWatcher.refCount++;
|
|
} else {
|
|
directoryWatcher = {
|
|
watcher: watchDirectory(dirName, (fileName) => {
|
|
if (isIgnoredPath(fileName, options))
|
|
return;
|
|
if (options == null ? void 0 : options.synchronousWatchDirectory) {
|
|
invokeCallbacks(dirPath, fileName);
|
|
updateChildWatches(dirName, dirPath, options);
|
|
} else {
|
|
nonSyncUpdateChildWatches(dirName, dirPath, fileName, options);
|
|
}
|
|
}, false, options),
|
|
refCount: 1,
|
|
childWatches: emptyArray
|
|
};
|
|
cache.set(dirPath, directoryWatcher);
|
|
updateChildWatches(dirName, dirPath, options);
|
|
}
|
|
const callbackToAdd = callback && { dirName, callback };
|
|
if (callbackToAdd) {
|
|
callbackCache.add(dirPath, callbackToAdd);
|
|
}
|
|
return {
|
|
dirName,
|
|
close: () => {
|
|
const directoryWatcher2 = Debug.checkDefined(cache.get(dirPath));
|
|
if (callbackToAdd)
|
|
callbackCache.remove(dirPath, callbackToAdd);
|
|
directoryWatcher2.refCount--;
|
|
if (directoryWatcher2.refCount)
|
|
return;
|
|
cache.delete(dirPath);
|
|
closeFileWatcherOf(directoryWatcher2);
|
|
directoryWatcher2.childWatches.forEach(closeFileWatcher);
|
|
}
|
|
};
|
|
}
|
|
function invokeCallbacks(dirPath, fileNameOrInvokeMap, fileNames) {
|
|
let fileName;
|
|
let invokeMap;
|
|
if (isString(fileNameOrInvokeMap)) {
|
|
fileName = fileNameOrInvokeMap;
|
|
} else {
|
|
invokeMap = fileNameOrInvokeMap;
|
|
}
|
|
callbackCache.forEach((callbacks, rootDirName) => {
|
|
if (invokeMap && invokeMap.get(rootDirName) === true)
|
|
return;
|
|
if (rootDirName === dirPath || startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === directorySeparator) {
|
|
if (invokeMap) {
|
|
if (fileNames) {
|
|
const existing = invokeMap.get(rootDirName);
|
|
if (existing) {
|
|
existing.push(...fileNames);
|
|
} else {
|
|
invokeMap.set(rootDirName, fileNames.slice());
|
|
}
|
|
} else {
|
|
invokeMap.set(rootDirName, true);
|
|
}
|
|
} else {
|
|
callbacks.forEach(({ callback }) => callback(fileName));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
|
|
const parentWatcher = cache.get(dirPath);
|
|
if (parentWatcher && fileSystemEntryExists(dirName, FileSystemEntryKind.Directory)) {
|
|
scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
|
|
return;
|
|
}
|
|
invokeCallbacks(dirPath, fileName);
|
|
removeChildWatches(parentWatcher);
|
|
}
|
|
function scheduleUpdateChildWatches(dirName, dirPath, fileName, options) {
|
|
const existing = cacheToUpdateChildWatches.get(dirPath);
|
|
if (existing) {
|
|
existing.fileNames.push(fileName);
|
|
} else {
|
|
cacheToUpdateChildWatches.set(dirPath, { dirName, options, fileNames: [fileName] });
|
|
}
|
|
if (timerToUpdateChildWatches) {
|
|
clearTimeout2(timerToUpdateChildWatches);
|
|
timerToUpdateChildWatches = void 0;
|
|
}
|
|
timerToUpdateChildWatches = setTimeout2(onTimerToUpdateChildWatches, 1e3);
|
|
}
|
|
function onTimerToUpdateChildWatches() {
|
|
timerToUpdateChildWatches = void 0;
|
|
sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
|
|
const start = timestamp();
|
|
const invokeMap = /* @__PURE__ */ new Map();
|
|
while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
|
|
const result = cacheToUpdateChildWatches.entries().next();
|
|
Debug.assert(!result.done);
|
|
const { value: [dirPath, { dirName, options, fileNames }] } = result;
|
|
cacheToUpdateChildWatches.delete(dirPath);
|
|
const hasChanges = updateChildWatches(dirName, dirPath, options);
|
|
invokeCallbacks(dirPath, invokeMap, hasChanges ? void 0 : fileNames);
|
|
}
|
|
sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start}ms:: ${cacheToUpdateChildWatches.size}`);
|
|
callbackCache.forEach((callbacks, rootDirName) => {
|
|
const existing = invokeMap.get(rootDirName);
|
|
if (existing) {
|
|
callbacks.forEach(({ callback, dirName }) => {
|
|
if (isArray(existing)) {
|
|
existing.forEach(callback);
|
|
} else {
|
|
callback(dirName);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
const elapsed = timestamp() - start;
|
|
sysLog(`sysLog:: Elapsed:: ${elapsed}ms:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size} ${timerToUpdateChildWatches}`);
|
|
}
|
|
function removeChildWatches(parentWatcher) {
|
|
if (!parentWatcher)
|
|
return;
|
|
const existingChildWatches = parentWatcher.childWatches;
|
|
parentWatcher.childWatches = emptyArray;
|
|
for (const childWatcher of existingChildWatches) {
|
|
childWatcher.close();
|
|
removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));
|
|
}
|
|
}
|
|
function updateChildWatches(parentDir, parentDirPath, options) {
|
|
const parentWatcher = cache.get(parentDirPath);
|
|
if (!parentWatcher)
|
|
return false;
|
|
let newChildWatches;
|
|
const hasChanges = enumerateInsertsAndDeletes(
|
|
fileSystemEntryExists(parentDir, FileSystemEntryKind.Directory) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
|
|
const childFullName = getNormalizedAbsolutePath(child, parentDir);
|
|
return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
|
|
}) : emptyArray,
|
|
parentWatcher.childWatches,
|
|
(child, childWatcher) => filePathComparer(child, childWatcher.dirName),
|
|
createAndAddChildDirectoryWatcher,
|
|
closeFileWatcher,
|
|
addChildDirectoryWatcher
|
|
);
|
|
parentWatcher.childWatches = newChildWatches || emptyArray;
|
|
return hasChanges;
|
|
function createAndAddChildDirectoryWatcher(childName) {
|
|
const result = createDirectoryWatcher(childName, options);
|
|
addChildDirectoryWatcher(result);
|
|
}
|
|
function addChildDirectoryWatcher(childWatcher) {
|
|
(newChildWatches || (newChildWatches = [])).push(childWatcher);
|
|
}
|
|
}
|
|
function isIgnoredPath(path, options) {
|
|
return some(ignoredPaths, (searchPath) => isInPath(path, searchPath)) || isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory);
|
|
}
|
|
function isInPath(path, searchPath) {
|
|
if (stringContains(path, searchPath))
|
|
return true;
|
|
if (useCaseSensitiveFileNames)
|
|
return false;
|
|
return stringContains(toCanonicalFilePath(path), searchPath);
|
|
}
|
|
}
|
|
var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
|
|
FileSystemEntryKind2[FileSystemEntryKind2["File"] = 0] = "File";
|
|
FileSystemEntryKind2[FileSystemEntryKind2["Directory"] = 1] = "Directory";
|
|
return FileSystemEntryKind2;
|
|
})(FileSystemEntryKind || {});
|
|
function createFileWatcherCallback(callback) {
|
|
return (_fileName, eventKind, modifiedTime) => callback(eventKind === 1 /* Changed */ ? "change" : "rename", "", modifiedTime);
|
|
}
|
|
function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime3) {
|
|
return (eventName, _relativeFileName, modifiedTime) => {
|
|
if (eventName === "rename") {
|
|
modifiedTime || (modifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime);
|
|
callback(fileName, modifiedTime !== missingFileModifiedTime ? 0 /* Created */ : 2 /* Deleted */, modifiedTime);
|
|
} else {
|
|
callback(fileName, 1 /* Changed */, modifiedTime);
|
|
}
|
|
};
|
|
}
|
|
function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames, getCurrentDirectory) {
|
|
return ((options == null ? void 0 : options.excludeDirectories) || (options == null ? void 0 : options.excludeFiles)) && (matchesExclude(pathToCheck, options == null ? void 0 : options.excludeFiles, useCaseSensitiveFileNames, getCurrentDirectory()) || matchesExclude(pathToCheck, options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames, getCurrentDirectory()));
|
|
}
|
|
function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory) {
|
|
return (eventName, relativeFileName) => {
|
|
if (eventName === "rename") {
|
|
const fileName = !relativeFileName ? directoryName : normalizePath(combinePaths(directoryName, relativeFileName));
|
|
if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames, getCurrentDirectory)) {
|
|
callback(fileName);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function createSystemWatchFunctions({
|
|
pollingWatchFileWorker,
|
|
getModifiedTime: getModifiedTime3,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2,
|
|
fsWatchWorker,
|
|
fileSystemEntryExists,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fsSupportsRecursiveFsWatch,
|
|
getAccessibleSortedChildDirectories,
|
|
realpath,
|
|
tscWatchFile,
|
|
useNonPollingWatchers,
|
|
tscWatchDirectory,
|
|
inodeWatching,
|
|
sysLog: sysLog2
|
|
}) {
|
|
const pollingWatches = /* @__PURE__ */ new Map();
|
|
const fsWatches = /* @__PURE__ */ new Map();
|
|
const fsWatchesRecursive = /* @__PURE__ */ new Map();
|
|
let dynamicPollingWatchFile;
|
|
let fixedChunkSizePollingWatchFile;
|
|
let nonPollingWatchFile;
|
|
let hostRecursiveDirectoryWatcher;
|
|
let hitSystemWatcherLimit = false;
|
|
return {
|
|
watchFile: watchFile2,
|
|
watchDirectory
|
|
};
|
|
function watchFile2(fileName, callback, pollingInterval, options) {
|
|
options = updateOptionsForWatchFile(options, useNonPollingWatchers);
|
|
const watchFileKind = Debug.checkDefined(options.watchFile);
|
|
switch (watchFileKind) {
|
|
case 0 /* FixedPollingInterval */:
|
|
return pollingWatchFile(fileName, callback, 250 /* Low */, void 0);
|
|
case 1 /* PriorityPollingInterval */:
|
|
return pollingWatchFile(fileName, callback, pollingInterval, void 0);
|
|
case 2 /* DynamicPriorityPolling */:
|
|
return ensureDynamicPollingWatchFile()(fileName, callback, pollingInterval, void 0);
|
|
case 3 /* FixedChunkSizePolling */:
|
|
return ensureFixedChunkSizePollingWatchFile()(fileName, callback, void 0, void 0);
|
|
case 4 /* UseFsEvents */:
|
|
return fsWatch(
|
|
fileName,
|
|
0 /* File */,
|
|
createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime3),
|
|
false,
|
|
pollingInterval,
|
|
getFallbackOptions(options)
|
|
);
|
|
case 5 /* UseFsEventsOnParentDirectory */:
|
|
if (!nonPollingWatchFile) {
|
|
nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames);
|
|
}
|
|
return nonPollingWatchFile(fileName, callback, pollingInterval, getFallbackOptions(options));
|
|
default:
|
|
Debug.assertNever(watchFileKind);
|
|
}
|
|
}
|
|
function ensureDynamicPollingWatchFile() {
|
|
return dynamicPollingWatchFile || (dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime3, setTimeout: setTimeout2 }));
|
|
}
|
|
function ensureFixedChunkSizePollingWatchFile() {
|
|
return fixedChunkSizePollingWatchFile || (fixedChunkSizePollingWatchFile = createFixedChunkSizePollingWatchFile({ getModifiedTime: getModifiedTime3, setTimeout: setTimeout2 }));
|
|
}
|
|
function updateOptionsForWatchFile(options, useNonPollingWatchers2) {
|
|
if (options && options.watchFile !== void 0)
|
|
return options;
|
|
switch (tscWatchFile) {
|
|
case "PriorityPollingInterval":
|
|
return { watchFile: 1 /* PriorityPollingInterval */ };
|
|
case "DynamicPriorityPolling":
|
|
return { watchFile: 2 /* DynamicPriorityPolling */ };
|
|
case "UseFsEvents":
|
|
return generateWatchFileOptions(4 /* UseFsEvents */, 1 /* PriorityInterval */, options);
|
|
case "UseFsEventsWithFallbackDynamicPolling":
|
|
return generateWatchFileOptions(4 /* UseFsEvents */, 2 /* DynamicPriority */, options);
|
|
case "UseFsEventsOnParentDirectory":
|
|
useNonPollingWatchers2 = true;
|
|
default:
|
|
return useNonPollingWatchers2 ? generateWatchFileOptions(5 /* UseFsEventsOnParentDirectory */, 1 /* PriorityInterval */, options) : { watchFile: 4 /* UseFsEvents */ };
|
|
}
|
|
}
|
|
function generateWatchFileOptions(watchFile3, fallbackPolling, options) {
|
|
const defaultFallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchFile: watchFile3,
|
|
fallbackPolling: defaultFallbackPolling === void 0 ? fallbackPolling : defaultFallbackPolling
|
|
};
|
|
}
|
|
function watchDirectory(directoryName, callback, recursive, options) {
|
|
if (fsSupportsRecursiveFsWatch) {
|
|
return fsWatch(
|
|
directoryName,
|
|
1 /* Directory */,
|
|
createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
|
|
recursive,
|
|
500 /* Medium */,
|
|
getFallbackOptions(options)
|
|
);
|
|
}
|
|
if (!hostRecursiveDirectoryWatcher) {
|
|
hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fileSystemEntryExists,
|
|
getAccessibleSortedChildDirectories,
|
|
watchDirectory: nonRecursiveWatchDirectory,
|
|
realpath,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2
|
|
});
|
|
}
|
|
return hostRecursiveDirectoryWatcher(directoryName, callback, recursive, options);
|
|
}
|
|
function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) {
|
|
Debug.assert(!recursive);
|
|
const watchDirectoryOptions = updateOptionsForWatchDirectory(options);
|
|
const watchDirectoryKind = Debug.checkDefined(watchDirectoryOptions.watchDirectory);
|
|
switch (watchDirectoryKind) {
|
|
case 1 /* FixedPollingInterval */:
|
|
return pollingWatchFile(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
500 /* Medium */,
|
|
void 0
|
|
);
|
|
case 2 /* DynamicPriorityPolling */:
|
|
return ensureDynamicPollingWatchFile()(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
500 /* Medium */,
|
|
void 0
|
|
);
|
|
case 3 /* FixedChunkSizePolling */:
|
|
return ensureFixedChunkSizePollingWatchFile()(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
void 0,
|
|
void 0
|
|
);
|
|
case 0 /* UseFsEvents */:
|
|
return fsWatch(
|
|
directoryName,
|
|
1 /* Directory */,
|
|
createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
|
|
recursive,
|
|
500 /* Medium */,
|
|
getFallbackOptions(watchDirectoryOptions)
|
|
);
|
|
default:
|
|
Debug.assertNever(watchDirectoryKind);
|
|
}
|
|
}
|
|
function updateOptionsForWatchDirectory(options) {
|
|
if (options && options.watchDirectory !== void 0)
|
|
return options;
|
|
switch (tscWatchDirectory) {
|
|
case "RecursiveDirectoryUsingFsWatchFile":
|
|
return { watchDirectory: 1 /* FixedPollingInterval */ };
|
|
case "RecursiveDirectoryUsingDynamicPriorityPolling":
|
|
return { watchDirectory: 2 /* DynamicPriorityPolling */ };
|
|
default:
|
|
const defaultFallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchDirectory: 0 /* UseFsEvents */,
|
|
fallbackPolling: defaultFallbackPolling !== void 0 ? defaultFallbackPolling : void 0
|
|
};
|
|
}
|
|
}
|
|
function pollingWatchFile(fileName, callback, pollingInterval, options) {
|
|
return createSingleWatcherPerName(
|
|
pollingWatches,
|
|
useCaseSensitiveFileNames,
|
|
fileName,
|
|
callback,
|
|
(cb) => pollingWatchFileWorker(fileName, cb, pollingInterval, options)
|
|
);
|
|
}
|
|
function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
|
|
return createSingleWatcherPerName(
|
|
recursive ? fsWatchesRecursive : fsWatches,
|
|
useCaseSensitiveFileNames,
|
|
fileOrDirectory,
|
|
callback,
|
|
(cb) => fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions)
|
|
);
|
|
}
|
|
function fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
|
|
let lastDirectoryPartWithDirectorySeparator;
|
|
let lastDirectoryPart;
|
|
if (inodeWatching) {
|
|
lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substring(fileOrDirectory.lastIndexOf(directorySeparator));
|
|
lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(directorySeparator.length);
|
|
}
|
|
let watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry() : watchPresentFileSystemEntry();
|
|
return {
|
|
close: () => {
|
|
if (watcher) {
|
|
watcher.close();
|
|
watcher = void 0;
|
|
}
|
|
}
|
|
};
|
|
function updateWatcher(createWatcher) {
|
|
if (watcher) {
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Changing watcher to ${createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing"}FileSystemEntryWatcher`);
|
|
watcher.close();
|
|
watcher = createWatcher();
|
|
}
|
|
}
|
|
function watchPresentFileSystemEntry() {
|
|
if (hitSystemWatcherLimit) {
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Defaulting to watchFile`);
|
|
return watchPresentFileSystemEntryWithFsWatchFile();
|
|
}
|
|
try {
|
|
const presentWatcher = fsWatchWorker(
|
|
fileOrDirectory,
|
|
recursive,
|
|
inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
|
|
);
|
|
presentWatcher.on("error", () => {
|
|
callback("rename", "");
|
|
updateWatcher(watchMissingFileSystemEntry);
|
|
});
|
|
return presentWatcher;
|
|
} catch (e) {
|
|
hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Changing to watchFile`);
|
|
return watchPresentFileSystemEntryWithFsWatchFile();
|
|
}
|
|
}
|
|
function callbackChangingToMissingFileSystemEntry(event, relativeName) {
|
|
let originalRelativeName;
|
|
if (relativeName && endsWith(relativeName, "~")) {
|
|
originalRelativeName = relativeName;
|
|
relativeName = relativeName.slice(0, relativeName.length - 1);
|
|
}
|
|
if (event === "rename" && (!relativeName || relativeName === lastDirectoryPart || endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) {
|
|
const modifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime;
|
|
if (originalRelativeName)
|
|
callback(event, originalRelativeName, modifiedTime);
|
|
callback(event, relativeName, modifiedTime);
|
|
if (inodeWatching) {
|
|
updateWatcher(modifiedTime === missingFileModifiedTime ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
|
|
} else if (modifiedTime === missingFileModifiedTime) {
|
|
updateWatcher(watchMissingFileSystemEntry);
|
|
}
|
|
} else {
|
|
if (originalRelativeName)
|
|
callback(event, originalRelativeName);
|
|
callback(event, relativeName);
|
|
}
|
|
}
|
|
function watchPresentFileSystemEntryWithFsWatchFile() {
|
|
return watchFile2(
|
|
fileOrDirectory,
|
|
createFileWatcherCallback(callback),
|
|
fallbackPollingInterval,
|
|
fallbackOptions
|
|
);
|
|
}
|
|
function watchMissingFileSystemEntry() {
|
|
return watchFile2(
|
|
fileOrDirectory,
|
|
(_fileName, eventKind, modifiedTime) => {
|
|
if (eventKind === 0 /* Created */) {
|
|
modifiedTime || (modifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime);
|
|
if (modifiedTime !== missingFileModifiedTime) {
|
|
callback("rename", "", modifiedTime);
|
|
updateWatcher(watchPresentFileSystemEntry);
|
|
}
|
|
}
|
|
},
|
|
fallbackPollingInterval,
|
|
fallbackOptions
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function patchWriteFileEnsuringDirectory(sys2) {
|
|
const originalWriteFile = sys2.writeFile;
|
|
sys2.writeFile = (path, data, writeBom) => writeFileEnsuringDirectories(
|
|
path,
|
|
data,
|
|
!!writeBom,
|
|
(path2, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path2, data2, writeByteOrderMark),
|
|
(path2) => sys2.createDirectory(path2),
|
|
(path2) => sys2.directoryExists(path2)
|
|
);
|
|
}
|
|
function getNodeMajorVersion() {
|
|
if (typeof process === "undefined") {
|
|
return void 0;
|
|
}
|
|
const version2 = process.version;
|
|
if (!version2) {
|
|
return void 0;
|
|
}
|
|
const dot = version2.indexOf(".");
|
|
if (dot === -1) {
|
|
return void 0;
|
|
}
|
|
return parseInt(version2.substring(1, dot));
|
|
}
|
|
var sys = (() => {
|
|
const byteOrderMarkIndicator = "\uFEFF";
|
|
function getNodeSystem() {
|
|
const nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/;
|
|
const _fs = require("fs");
|
|
const _path = require("path");
|
|
const _os = require("os");
|
|
let _crypto;
|
|
try {
|
|
_crypto = require("crypto");
|
|
} catch (e) {
|
|
_crypto = void 0;
|
|
}
|
|
let activeSession;
|
|
let profilePath = "./profile.cpuprofile";
|
|
const Buffer2 = require("buffer").Buffer;
|
|
const nodeVersion = getNodeMajorVersion();
|
|
const isNode4OrLater = nodeVersion >= 4;
|
|
const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
|
|
const platform = _os.platform();
|
|
const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
|
|
const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
|
|
const executingFilePath = __filename.endsWith("sys.js") ? _path.join(_path.dirname(__dirname), "__fake__.js") : __filename;
|
|
const fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
|
|
const getCurrentDirectory = memoize(() => process.cwd());
|
|
const { watchFile: watchFile2, watchDirectory } = createSystemWatchFunctions({
|
|
pollingWatchFileWorker: fsWatchFileWorker,
|
|
getModifiedTime: getModifiedTime3,
|
|
setTimeout,
|
|
clearTimeout,
|
|
fsWatchWorker,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fileSystemEntryExists,
|
|
fsSupportsRecursiveFsWatch,
|
|
getAccessibleSortedChildDirectories: (path) => getAccessibleFileSystemEntries(path).directories,
|
|
realpath,
|
|
tscWatchFile: process.env.TSC_WATCHFILE,
|
|
useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
|
|
tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
|
|
inodeWatching: isLinuxOrMacOs,
|
|
sysLog
|
|
});
|
|
const nodeSystem = {
|
|
args: process.argv.slice(2),
|
|
newLine: _os.EOL,
|
|
useCaseSensitiveFileNames,
|
|
write(s) {
|
|
process.stdout.write(s);
|
|
},
|
|
getWidthOfTerminal() {
|
|
return process.stdout.columns;
|
|
},
|
|
writeOutputIsTTY() {
|
|
return process.stdout.isTTY;
|
|
},
|
|
readFile,
|
|
writeFile: writeFile2,
|
|
watchFile: watchFile2,
|
|
watchDirectory,
|
|
resolvePath: (path) => _path.resolve(path),
|
|
fileExists,
|
|
directoryExists,
|
|
createDirectory(directoryName) {
|
|
if (!nodeSystem.directoryExists(directoryName)) {
|
|
try {
|
|
_fs.mkdirSync(directoryName);
|
|
} catch (e) {
|
|
if (e.code !== "EEXIST") {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getExecutingFilePath() {
|
|
return executingFilePath;
|
|
},
|
|
getCurrentDirectory,
|
|
getDirectories,
|
|
getEnvironmentVariable(name) {
|
|
return process.env[name] || "";
|
|
},
|
|
readDirectory,
|
|
getModifiedTime: getModifiedTime3,
|
|
setModifiedTime,
|
|
deleteFile,
|
|
createHash: _crypto ? createSHA256Hash : generateDjb2Hash,
|
|
createSHA256Hash: _crypto ? createSHA256Hash : void 0,
|
|
getMemoryUsage() {
|
|
if (global.gc) {
|
|
global.gc();
|
|
}
|
|
return process.memoryUsage().heapUsed;
|
|
},
|
|
getFileSize(path) {
|
|
try {
|
|
const stat = statSync(path);
|
|
if (stat == null ? void 0 : stat.isFile()) {
|
|
return stat.size;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return 0;
|
|
},
|
|
exit(exitCode) {
|
|
disableCPUProfiler(() => process.exit(exitCode));
|
|
},
|
|
enableCPUProfiler,
|
|
disableCPUProfiler,
|
|
cpuProfilingEnabled: () => !!activeSession || contains(process.execArgv, "--cpu-prof") || contains(process.execArgv, "--prof"),
|
|
realpath,
|
|
debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || some(process.execArgv, (arg) => /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg)),
|
|
tryEnableSourceMapsForHost() {
|
|
try {
|
|
require("source-map-support").install();
|
|
} catch (e) {
|
|
}
|
|
},
|
|
setTimeout,
|
|
clearTimeout,
|
|
clearScreen: () => {
|
|
process.stdout.write("\x1Bc");
|
|
},
|
|
setBlocking: () => {
|
|
if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) {
|
|
process.stdout._handle.setBlocking(true);
|
|
}
|
|
},
|
|
bufferFrom,
|
|
base64decode: (input) => bufferFrom(input, "base64").toString("utf8"),
|
|
base64encode: (input) => bufferFrom(input).toString("base64"),
|
|
require: (baseDir, moduleName) => {
|
|
try {
|
|
const modulePath = resolveJSModule(moduleName, baseDir, nodeSystem);
|
|
return { module: require(modulePath), modulePath, error: void 0 };
|
|
} catch (error) {
|
|
return { module: void 0, modulePath: void 0, error };
|
|
}
|
|
}
|
|
};
|
|
return nodeSystem;
|
|
function statSync(path) {
|
|
return _fs.statSync(path, { throwIfNoEntry: false });
|
|
}
|
|
function enableCPUProfiler(path, cb) {
|
|
if (activeSession) {
|
|
cb();
|
|
return false;
|
|
}
|
|
const inspector = require("inspector");
|
|
if (!inspector || !inspector.Session) {
|
|
cb();
|
|
return false;
|
|
}
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
session.post("Profiler.enable", () => {
|
|
session.post("Profiler.start", () => {
|
|
activeSession = session;
|
|
profilePath = path;
|
|
cb();
|
|
});
|
|
});
|
|
return true;
|
|
}
|
|
function cleanupPaths(profile) {
|
|
let externalFileCounter = 0;
|
|
const remappedPaths = /* @__PURE__ */ new Map();
|
|
const normalizedDir = normalizeSlashes(_path.dirname(executingFilePath));
|
|
const fileUrlRoot = `file://${getRootLength(normalizedDir) === 1 ? "" : "/"}${normalizedDir}`;
|
|
for (const node of profile.nodes) {
|
|
if (node.callFrame.url) {
|
|
const url = normalizeSlashes(node.callFrame.url);
|
|
if (containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) {
|
|
node.callFrame.url = getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, createGetCanonicalFileName(useCaseSensitiveFileNames), true);
|
|
} else if (!nativePattern.test(url)) {
|
|
node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, `external${externalFileCounter}.js`)).get(url);
|
|
externalFileCounter++;
|
|
}
|
|
}
|
|
}
|
|
return profile;
|
|
}
|
|
function disableCPUProfiler(cb) {
|
|
if (activeSession && activeSession !== "stopping") {
|
|
const s = activeSession;
|
|
activeSession.post("Profiler.stop", (err, { profile }) => {
|
|
var _a2;
|
|
if (!err) {
|
|
try {
|
|
if ((_a2 = statSync(profilePath)) == null ? void 0 : _a2.isDirectory()) {
|
|
profilePath = _path.join(profilePath, `${new Date().toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
|
|
}
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
_fs.mkdirSync(_path.dirname(profilePath), { recursive: true });
|
|
} catch (e) {
|
|
}
|
|
_fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile)));
|
|
}
|
|
activeSession = void 0;
|
|
s.disconnect();
|
|
cb();
|
|
});
|
|
activeSession = "stopping";
|
|
return true;
|
|
} else {
|
|
cb();
|
|
return false;
|
|
}
|
|
}
|
|
function bufferFrom(input, encoding) {
|
|
return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
|
|
}
|
|
function isFileSystemCaseSensitive() {
|
|
if (platform === "win32" || platform === "win64") {
|
|
return false;
|
|
}
|
|
return !fileExists(swapCase(__filename));
|
|
}
|
|
function swapCase(s) {
|
|
return s.replace(/\w/g, (ch) => {
|
|
const up = ch.toUpperCase();
|
|
return ch === up ? ch.toLowerCase() : up;
|
|
});
|
|
}
|
|
function fsWatchFileWorker(fileName, callback, pollingInterval) {
|
|
_fs.watchFile(fileName, { persistent: true, interval: pollingInterval }, fileChanged);
|
|
let eventKind;
|
|
return {
|
|
close: () => _fs.unwatchFile(fileName, fileChanged)
|
|
};
|
|
function fileChanged(curr, prev) {
|
|
const isPreviouslyDeleted = +prev.mtime === 0 || eventKind === 2 /* Deleted */;
|
|
if (+curr.mtime === 0) {
|
|
if (isPreviouslyDeleted) {
|
|
return;
|
|
}
|
|
eventKind = 2 /* Deleted */;
|
|
} else if (isPreviouslyDeleted) {
|
|
eventKind = 0 /* Created */;
|
|
} else if (+curr.mtime === +prev.mtime) {
|
|
return;
|
|
} else {
|
|
eventKind = 1 /* Changed */;
|
|
}
|
|
callback(fileName, eventKind, curr.mtime);
|
|
}
|
|
}
|
|
function fsWatchWorker(fileOrDirectory, recursive, callback) {
|
|
return _fs.watch(
|
|
fileOrDirectory,
|
|
fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true },
|
|
callback
|
|
);
|
|
}
|
|
function readFileWorker(fileName, _encoding) {
|
|
let buffer;
|
|
try {
|
|
buffer = _fs.readFileSync(fileName);
|
|
} catch (e) {
|
|
return void 0;
|
|
}
|
|
let len = buffer.length;
|
|
if (len >= 2 && buffer[0] === 254 && buffer[1] === 255) {
|
|
len &= ~1;
|
|
for (let i = 0; i < len; i += 2) {
|
|
const temp = buffer[i];
|
|
buffer[i] = buffer[i + 1];
|
|
buffer[i + 1] = temp;
|
|
}
|
|
return buffer.toString("utf16le", 2);
|
|
}
|
|
if (len >= 2 && buffer[0] === 255 && buffer[1] === 254) {
|
|
return buffer.toString("utf16le", 2);
|
|
}
|
|
if (len >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
|
|
return buffer.toString("utf8", 3);
|
|
}
|
|
return buffer.toString("utf8");
|
|
}
|
|
function readFile(fileName, _encoding) {
|
|
perfLogger.logStartReadFile(fileName);
|
|
const file = readFileWorker(fileName, _encoding);
|
|
perfLogger.logStopReadFile();
|
|
return file;
|
|
}
|
|
function writeFile2(fileName, data, writeByteOrderMark) {
|
|
perfLogger.logEvent("WriteFile: " + fileName);
|
|
if (writeByteOrderMark) {
|
|
data = byteOrderMarkIndicator + data;
|
|
}
|
|
let fd;
|
|
try {
|
|
fd = _fs.openSync(fileName, "w");
|
|
_fs.writeSync(fd, data, void 0, "utf8");
|
|
} finally {
|
|
if (fd !== void 0) {
|
|
_fs.closeSync(fd);
|
|
}
|
|
}
|
|
}
|
|
function getAccessibleFileSystemEntries(path) {
|
|
perfLogger.logEvent("ReadDir: " + (path || "."));
|
|
try {
|
|
const entries = _fs.readdirSync(path || ".", { withFileTypes: true });
|
|
const files = [];
|
|
const directories = [];
|
|
for (const dirent of entries) {
|
|
const entry = typeof dirent === "string" ? dirent : dirent.name;
|
|
if (entry === "." || entry === "..") {
|
|
continue;
|
|
}
|
|
let stat;
|
|
if (typeof dirent === "string" || dirent.isSymbolicLink()) {
|
|
const name = 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, directories };
|
|
} catch (e) {
|
|
return emptyFileSystemEntries;
|
|
}
|
|
}
|
|
function readDirectory(path, extensions, excludes, includes, depth) {
|
|
return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
|
|
}
|
|
function fileSystemEntryExists(path, entryKind) {
|
|
const originalStackTraceLimit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 0;
|
|
try {
|
|
const stat = statSync(path);
|
|
if (!stat) {
|
|
return false;
|
|
}
|
|
switch (entryKind) {
|
|
case 0 /* File */:
|
|
return stat.isFile();
|
|
case 1 /* Directory */:
|
|
return stat.isDirectory();
|
|
default:
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
return false;
|
|
} finally {
|
|
Error.stackTraceLimit = originalStackTraceLimit;
|
|
}
|
|
}
|
|
function fileExists(path) {
|
|
return fileSystemEntryExists(path, 0 /* File */);
|
|
}
|
|
function directoryExists(path) {
|
|
return fileSystemEntryExists(path, 1 /* 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 (e) {
|
|
return path;
|
|
}
|
|
}
|
|
function getModifiedTime3(path) {
|
|
var _a2;
|
|
const originalStackTraceLimit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 0;
|
|
try {
|
|
return (_a2 = statSync(path)) == null ? void 0 : _a2.mtime;
|
|
} catch (e) {
|
|
return void 0;
|
|
} 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) {
|
|
const hash = _crypto.createHash("sha256");
|
|
hash.update(data);
|
|
return hash.digest("hex");
|
|
}
|
|
}
|
|
let sys2;
|
|
if (isNodeLikeSystem()) {
|
|
sys2 = getNodeSystem();
|
|
}
|
|
if (sys2) {
|
|
patchWriteFileEnsuringDirectory(sys2);
|
|
}
|
|
return sys2;
|
|
})();
|
|
if (sys && sys.getEnvironmentVariable) {
|
|
setCustomPollingValues(sys);
|
|
Debug.setAssertionLevel(/^development$/i.test(sys.getEnvironmentVariable("NODE_ENV")) ? 1 /* Normal */ : 0 /* None */);
|
|
}
|
|
if (sys && sys.debugMode) {
|
|
Debug.isDebugging = true;
|
|
}
|
|
|
|
// src/compiler/path.ts
|
|
var directorySeparator = "/";
|
|
var altDirectorySeparator = "\\";
|
|
var urlSchemeSeparator = "://";
|
|
var backslashRegExp = /\\/g;
|
|
function isAnyDirectorySeparator(charCode) {
|
|
return charCode === 47 /* slash */ || charCode === 92 /* backslash */;
|
|
}
|
|
function isRootedDiskPath(path) {
|
|
return getEncodedRootLength(path) > 0;
|
|
}
|
|
function pathIsAbsolute(path) {
|
|
return getEncodedRootLength(path) !== 0;
|
|
}
|
|
function pathIsRelative(path) {
|
|
return /^\.\.?($|[\\/])/.test(path);
|
|
}
|
|
function pathIsBareSpecifier(path) {
|
|
return !pathIsAbsolute(path) && !pathIsRelative(path);
|
|
}
|
|
function hasExtension(fileName) {
|
|
return stringContains(getBaseFileName(fileName), ".");
|
|
}
|
|
function fileExtensionIs(path, extension) {
|
|
return path.length > extension.length && endsWith(path, extension);
|
|
}
|
|
function fileExtensionIsOneOf(path, extensions) {
|
|
for (const extension of extensions) {
|
|
if (fileExtensionIs(path, extension)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function hasTrailingDirectorySeparator(path) {
|
|
return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
|
|
}
|
|
function isVolumeCharacter(charCode) {
|
|
return charCode >= 97 /* a */ && charCode <= 122 /* z */ || charCode >= 65 /* A */ && charCode <= 90 /* Z */;
|
|
}
|
|
function getFileUrlVolumeSeparatorEnd(url, start) {
|
|
const ch0 = url.charCodeAt(start);
|
|
if (ch0 === 58 /* colon */)
|
|
return start + 1;
|
|
if (ch0 === 37 /* percent */ && url.charCodeAt(start + 1) === 51 /* _3 */) {
|
|
const ch2 = url.charCodeAt(start + 2);
|
|
if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
|
|
return start + 3;
|
|
}
|
|
return -1;
|
|
}
|
|
function getEncodedRootLength(path) {
|
|
if (!path)
|
|
return 0;
|
|
const ch0 = path.charCodeAt(0);
|
|
if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
|
|
if (path.charCodeAt(1) !== ch0)
|
|
return 1;
|
|
const p1 = path.indexOf(ch0 === 47 /* slash */ ? directorySeparator : altDirectorySeparator, 2);
|
|
if (p1 < 0)
|
|
return path.length;
|
|
return p1 + 1;
|
|
}
|
|
if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
|
|
const ch2 = path.charCodeAt(2);
|
|
if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
|
|
return 3;
|
|
if (path.length === 2)
|
|
return 2;
|
|
}
|
|
const schemeEnd = path.indexOf(urlSchemeSeparator);
|
|
if (schemeEnd !== -1) {
|
|
const authorityStart = schemeEnd + urlSchemeSeparator.length;
|
|
const authorityEnd = path.indexOf(directorySeparator, authorityStart);
|
|
if (authorityEnd !== -1) {
|
|
const scheme = path.slice(0, schemeEnd);
|
|
const authority = path.slice(authorityStart, authorityEnd);
|
|
if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
|
|
const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
|
|
if (volumeSeparatorEnd !== -1) {
|
|
if (path.charCodeAt(volumeSeparatorEnd) === 47 /* slash */) {
|
|
return ~(volumeSeparatorEnd + 1);
|
|
}
|
|
if (volumeSeparatorEnd === path.length) {
|
|
return ~volumeSeparatorEnd;
|
|
}
|
|
}
|
|
}
|
|
return ~(authorityEnd + 1);
|
|
}
|
|
return ~path.length;
|
|
}
|
|
return 0;
|
|
}
|
|
function getRootLength(path) {
|
|
const rootLength = getEncodedRootLength(path);
|
|
return rootLength < 0 ? ~rootLength : rootLength;
|
|
}
|
|
function getDirectoryPath(path) {
|
|
path = normalizeSlashes(path);
|
|
const rootLength = getRootLength(path);
|
|
if (rootLength === path.length)
|
|
return path;
|
|
path = removeTrailingDirectorySeparator(path);
|
|
return path.slice(0, Math.max(rootLength, path.lastIndexOf(directorySeparator)));
|
|
}
|
|
function getBaseFileName(path, extensions, ignoreCase) {
|
|
path = normalizeSlashes(path);
|
|
const rootLength = getRootLength(path);
|
|
if (rootLength === path.length)
|
|
return "";
|
|
path = removeTrailingDirectorySeparator(path);
|
|
const name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(directorySeparator) + 1));
|
|
const extension = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(name, extensions, ignoreCase) : void 0;
|
|
return extension ? name.slice(0, name.length - extension.length) : name;
|
|
}
|
|
function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
|
|
if (!startsWith(extension, "."))
|
|
extension = "." + extension;
|
|
if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* dot */) {
|
|
const 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 (const extension of extensions) {
|
|
const result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return "";
|
|
}
|
|
function getAnyExtensionFromPath(path, extensions, ignoreCase) {
|
|
if (extensions) {
|
|
return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
|
|
}
|
|
const baseFileName = getBaseFileName(path);
|
|
const extensionIndex = baseFileName.lastIndexOf(".");
|
|
if (extensionIndex >= 0) {
|
|
return baseFileName.substring(extensionIndex);
|
|
}
|
|
return "";
|
|
}
|
|
function pathComponents(path, rootLength) {
|
|
const root = path.substring(0, rootLength);
|
|
const rest = path.substring(rootLength).split(directorySeparator);
|
|
if (rest.length && !lastOrUndefined(rest))
|
|
rest.pop();
|
|
return [root, ...rest];
|
|
}
|
|
function getPathComponents(path, currentDirectory = "") {
|
|
path = combinePaths(currentDirectory, path);
|
|
return pathComponents(path, getRootLength(path));
|
|
}
|
|
function getPathFromPathComponents(pathComponents2) {
|
|
if (pathComponents2.length === 0)
|
|
return "";
|
|
const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
|
|
return root + pathComponents2.slice(1).join(directorySeparator);
|
|
}
|
|
function normalizeSlashes(path) {
|
|
return path.indexOf("\\") !== -1 ? path.replace(backslashRegExp, directorySeparator) : path;
|
|
}
|
|
function reducePathComponents(components) {
|
|
if (!some(components))
|
|
return [];
|
|
const reduced = [components[0]];
|
|
for (let i = 1; i < components.length; i++) {
|
|
const 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;
|
|
}
|
|
function combinePaths(path, ...paths) {
|
|
if (path)
|
|
path = normalizeSlashes(path);
|
|
for (let relativePath of paths) {
|
|
if (!relativePath)
|
|
continue;
|
|
relativePath = normalizeSlashes(relativePath);
|
|
if (!path || getRootLength(relativePath) !== 0) {
|
|
path = relativePath;
|
|
} else {
|
|
path = ensureTrailingDirectorySeparator(path) + relativePath;
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
function resolvePath(path, ...paths) {
|
|
return normalizePath(some(paths) ? combinePaths(path, ...paths) : normalizeSlashes(path));
|
|
}
|
|
function getNormalizedPathComponents(path, currentDirectory) {
|
|
return reducePathComponents(getPathComponents(path, currentDirectory));
|
|
}
|
|
function getNormalizedAbsolutePath(fileName, currentDirectory) {
|
|
return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
|
|
}
|
|
function normalizePath(path) {
|
|
path = normalizeSlashes(path);
|
|
if (!relativePathSegmentRegExp.test(path)) {
|
|
return path;
|
|
}
|
|
const simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
|
|
if (simplified !== path) {
|
|
path = simplified;
|
|
if (!relativePathSegmentRegExp.test(path)) {
|
|
return path;
|
|
}
|
|
}
|
|
const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
|
|
return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
|
|
}
|
|
function getPathWithoutRoot(pathComponents2) {
|
|
if (pathComponents2.length === 0)
|
|
return "";
|
|
return pathComponents2.slice(1).join(directorySeparator);
|
|
}
|
|
function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
|
|
return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
|
|
}
|
|
function toPath(fileName, basePath, getCanonicalFileName) {
|
|
const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
|
|
return getCanonicalFileName(nonCanonicalizedPath);
|
|
}
|
|
function removeTrailingDirectorySeparator(path) {
|
|
if (hasTrailingDirectorySeparator(path)) {
|
|
return path.substr(0, path.length - 1);
|
|
}
|
|
return path;
|
|
}
|
|
function ensureTrailingDirectorySeparator(path) {
|
|
if (!hasTrailingDirectorySeparator(path)) {
|
|
return path + directorySeparator;
|
|
}
|
|
return path;
|
|
}
|
|
function ensurePathIsNonModuleName(path) {
|
|
return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
|
|
}
|
|
function changeAnyExtension(path, ext, extensions, ignoreCase) {
|
|
const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
|
|
return pathext ? path.slice(0, path.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path;
|
|
}
|
|
var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
|
|
function comparePathsWorker(a, b, componentComparer) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
const aRoot = a.substring(0, getRootLength(a));
|
|
const bRoot = b.substring(0, getRootLength(b));
|
|
const result = compareStringsCaseInsensitive(aRoot, bRoot);
|
|
if (result !== 0 /* EqualTo */) {
|
|
return result;
|
|
}
|
|
const aRest = a.substring(aRoot.length);
|
|
const bRest = b.substring(bRoot.length);
|
|
if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
|
|
return componentComparer(aRest, bRest);
|
|
}
|
|
const aComponents = reducePathComponents(getPathComponents(a));
|
|
const bComponents = reducePathComponents(getPathComponents(b));
|
|
const sharedLength = Math.min(aComponents.length, bComponents.length);
|
|
for (let i = 1; i < sharedLength; i++) {
|
|
const result2 = componentComparer(aComponents[i], bComponents[i]);
|
|
if (result2 !== 0 /* EqualTo */) {
|
|
return result2;
|
|
}
|
|
}
|
|
return compareValues(aComponents.length, bComponents.length);
|
|
}
|
|
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, getStringComparer(ignoreCase));
|
|
}
|
|
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 === void 0 || child === void 0)
|
|
return false;
|
|
if (parent === child)
|
|
return true;
|
|
const parentComponents = reducePathComponents(getPathComponents(parent));
|
|
const childComponents = reducePathComponents(getPathComponents(child));
|
|
if (childComponents.length < parentComponents.length) {
|
|
return false;
|
|
}
|
|
const componentEqualityComparer = ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive;
|
|
for (let i = 0; i < parentComponents.length; i++) {
|
|
const equalityComparer = i === 0 ? equateStringsCaseInsensitive : componentEqualityComparer;
|
|
if (!equalityComparer(parentComponents[i], childComponents[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
|
|
const canonicalFileName = getCanonicalFileName(fileName);
|
|
const canonicalDirectoryName = getCanonicalFileName(directoryName);
|
|
return startsWith(canonicalFileName, canonicalDirectoryName + "/") || startsWith(canonicalFileName, canonicalDirectoryName + "\\");
|
|
}
|
|
function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
|
|
const fromComponents = reducePathComponents(getPathComponents(from));
|
|
const toComponents = reducePathComponents(getPathComponents(to));
|
|
let start;
|
|
for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
|
|
const fromComponent = getCanonicalFileName(fromComponents[start]);
|
|
const toComponent = getCanonicalFileName(toComponents[start]);
|
|
const comparer = start === 0 ? equateStringsCaseInsensitive : stringEqualityComparer;
|
|
if (!comparer(fromComponent, toComponent))
|
|
break;
|
|
}
|
|
if (start === 0) {
|
|
return toComponents;
|
|
}
|
|
const components = toComponents.slice(start);
|
|
const relative = [];
|
|
for (; start < fromComponents.length; start++) {
|
|
relative.push("..");
|
|
}
|
|
return ["", ...relative, ...components];
|
|
}
|
|
function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
|
|
Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
|
|
const getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : identity;
|
|
const ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
|
|
const pathComponents2 = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive, getCanonicalFileName);
|
|
return getPathFromPathComponents(pathComponents2);
|
|
}
|
|
function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
|
|
return !isRootedDiskPath(absoluteOrRelativePath) ? absoluteOrRelativePath : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
|
|
}
|
|
function getRelativePathFromFile(from, to, getCanonicalFileName) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
|
|
}
|
|
function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
|
|
const pathComponents2 = getPathComponentsRelativeTo(
|
|
resolvePath(currentDirectory, directoryPathOrUrl),
|
|
resolvePath(currentDirectory, relativeOrAbsolutePath),
|
|
equateStringsCaseSensitive,
|
|
getCanonicalFileName
|
|
);
|
|
const firstComponent = pathComponents2[0];
|
|
if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
|
|
const prefix = firstComponent.charAt(0) === directorySeparator ? "file://" : "file:///";
|
|
pathComponents2[0] = prefix + firstComponent;
|
|
}
|
|
return getPathFromPathComponents(pathComponents2);
|
|
}
|
|
function forEachAncestorDirectory(directory, callback) {
|
|
while (true) {
|
|
const result = callback(directory);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
const parentPath = getDirectoryPath(directory);
|
|
if (parentPath === directory) {
|
|
return void 0;
|
|
}
|
|
directory = parentPath;
|
|
}
|
|
}
|
|
function isNodeModulesDirectory(dirPath) {
|
|
return endsWith(dirPath, "/node_modules");
|
|
}
|
|
|
|
// src/compiler/diagnosticInformationMap.generated.ts
|
|
function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated) {
|
|
return { code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated };
|
|
}
|
|
var Diagnostics = {
|
|
Unterminated_string_literal: diag(1002, 1 /* Error */, "Unterminated_string_literal_1002", "Unterminated string literal."),
|
|
Identifier_expected: diag(1003, 1 /* Error */, "Identifier_expected_1003", "Identifier expected."),
|
|
_0_expected: diag(1005, 1 /* Error */, "_0_expected_1005", "'{0}' expected."),
|
|
A_file_cannot_have_a_reference_to_itself: diag(1006, 1 /* 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, 1 /* 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, 1 /* Error */, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."),
|
|
Asterisk_Slash_expected: diag(1010, 1 /* Error */, "Asterisk_Slash_expected_1010", "'*/' expected."),
|
|
An_element_access_expression_should_take_an_argument: diag(1011, 1 /* Error */, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."),
|
|
Unexpected_token: diag(1012, 1 /* Error */, "Unexpected_token_1012", "Unexpected token."),
|
|
A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "An_index_signature_cannot_have_a_trailing_comma_1025", "An index signature cannot have a trailing comma."),
|
|
Accessibility_modifier_already_seen: diag(1028, 1 /* Error */, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."),
|
|
_0_modifier_must_precede_1_modifier: diag(1029, 1 /* Error */, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."),
|
|
_0_modifier_already_seen: diag(1030, 1 /* Error */, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."),
|
|
_0_modifier_cannot_appear_on_class_elements_of_this_kind: diag(1031, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."),
|
|
A_rest_parameter_cannot_have_an_initializer: diag(1048, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."),
|
|
A_get_accessor_cannot_have_parameters: diag(1054, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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<T> type. Did you mean to write 'Promise<{0}>'?"),
|
|
In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."),
|
|
Type_parameter_list_cannot_be_empty: diag(1098, 1 /* Error */, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."),
|
|
Type_argument_list_cannot_be_empty: diag(1099, 1 /* Error */, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."),
|
|
Invalid_use_of_0_in_strict_mode: diag(1100, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Expression_expected_1109", "Expression expected."),
|
|
Type_expected: diag(1110, 1 /* Error */, "Type_expected_1110", "Type expected."),
|
|
A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, 1 /* 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, 1 /* Error */, "Duplicate_label_0_1114", "Duplicate label '{0}'."),
|
|
A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."),
|
|
Octal_literals_are_not_allowed_in_strict_mode: diag(1121, 1 /* 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, 1 /* Error */, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."),
|
|
Digit_expected: diag(1124, 1 /* Error */, "Digit_expected_1124", "Digit expected."),
|
|
Hexadecimal_digit_expected: diag(1125, 1 /* Error */, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."),
|
|
Unexpected_end_of_text: diag(1126, 1 /* Error */, "Unexpected_end_of_text_1126", "Unexpected end of text."),
|
|
Invalid_character: diag(1127, 1 /* Error */, "Invalid_character_1127", "Invalid character."),
|
|
Declaration_or_statement_expected: diag(1128, 1 /* Error */, "Declaration_or_statement_expected_1128", "Declaration or statement expected."),
|
|
Statement_expected: diag(1129, 1 /* Error */, "Statement_expected_1129", "Statement expected."),
|
|
case_or_default_expected: diag(1130, 1 /* Error */, "case_or_default_expected_1130", "'case' or 'default' expected."),
|
|
Property_or_signature_expected: diag(1131, 1 /* Error */, "Property_or_signature_expected_1131", "Property or signature expected."),
|
|
Enum_member_expected: diag(1132, 1 /* Error */, "Enum_member_expected_1132", "Enum member expected."),
|
|
Variable_declaration_expected: diag(1134, 1 /* Error */, "Variable_declaration_expected_1134", "Variable declaration expected."),
|
|
Argument_expression_expected: diag(1135, 1 /* Error */, "Argument_expression_expected_1135", "Argument expression expected."),
|
|
Property_assignment_expected: diag(1136, 1 /* Error */, "Property_assignment_expected_1136", "Property assignment expected."),
|
|
Expression_or_comma_expected: diag(1137, 1 /* Error */, "Expression_or_comma_expected_1137", "Expression or comma expected."),
|
|
Parameter_declaration_expected: diag(1138, 1 /* Error */, "Parameter_declaration_expected_1138", "Parameter declaration expected."),
|
|
Type_parameter_declaration_expected: diag(1139, 1 /* Error */, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."),
|
|
Type_argument_expected: diag(1140, 1 /* Error */, "Type_argument_expected_1140", "Type argument expected."),
|
|
String_literal_expected: diag(1141, 1 /* Error */, "String_literal_expected_1141", "String literal expected."),
|
|
Line_break_not_permitted_here: diag(1142, 1 /* Error */, "Line_break_not_permitted_here_1142", "Line break not permitted here."),
|
|
or_expected: diag(1144, 1 /* Error */, "or_expected_1144", "'{' or ';' expected."),
|
|
or_JSX_element_expected: diag(1145, 1 /* Error */, "or_JSX_element_expected_1145", "'{' or JSX element expected."),
|
|
Declaration_expected: diag(1146, 1 /* Error */, "Declaration_expected_1146", "Declaration expected."),
|
|
Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."),
|
|
const_declarations_can_only_be_declared_inside_a_block: diag(1156, 1 /* 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, 1 /* 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, 1 /* Error */, "Unterminated_template_literal_1160", "Unterminated template literal."),
|
|
Unterminated_regular_expression_literal: diag(1161, 1 /* Error */, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."),
|
|
An_object_member_cannot_be_declared_optional: diag(1162, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "extends_clause_already_seen_1172", "'extends' clause already seen."),
|
|
extends_clause_must_precede_implements_clause: diag(1173, 1 /* Error */, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."),
|
|
Classes_can_only_extend_a_single_class: diag(1174, 1 /* Error */, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."),
|
|
implements_clause_already_seen: diag(1175, 1 /* Error */, "implements_clause_already_seen_1175", "'implements' clause already seen."),
|
|
Interface_declaration_cannot_have_implements_clause: diag(1176, 1 /* Error */, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."),
|
|
Binary_digit_expected: diag(1177, 1 /* Error */, "Binary_digit_expected_1177", "Binary digit expected."),
|
|
Octal_digit_expected: diag(1178, 1 /* Error */, "Octal_digit_expected_1178", "Octal digit expected."),
|
|
Unexpected_token_expected: diag(1179, 1 /* Error */, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."),
|
|
Property_destructuring_pattern_expected: diag(1180, 1 /* Error */, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."),
|
|
Array_element_destructuring_pattern_expected: diag(1181, 1 /* Error */, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."),
|
|
A_destructuring_declaration_must_have_an_initializer: diag(1182, 1 /* 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, 1 /* Error */, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."),
|
|
Modifiers_cannot_appear_here: diag(1184, 1 /* Error */, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."),
|
|
Merge_conflict_marker_encountered: diag(1185, 1 /* Error */, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."),
|
|
A_rest_element_cannot_have_an_initializer: diag(1186, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."),
|
|
Module_0_has_no_default_export: diag(1192, 1 /* Error */, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."),
|
|
An_export_declaration_cannot_have_modifiers: diag(1193, 1 /* Error */, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."),
|
|
Export_declarations_are_not_permitted_in_a_namespace: diag(1194, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."),
|
|
Line_terminator_not_permitted_before_arrow: diag(1200, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "_0_tag_already_specified_1223", "'{0}' tag already specified."),
|
|
Signature_0_must_be_a_type_predicate: diag(1224, 1 /* Error */, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."),
|
|
Cannot_find_parameter_0: diag(1225, 1 /* Error */, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."),
|
|
Type_predicate_0_is_not_assignable_to_1: diag(1226, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."),
|
|
Type_arguments_cannot_be_used_here: diag(1342, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."),
|
|
use_strict_directive_used_here: diag(1349, 1 /* Error */, "use_strict_directive_used_here_1349", "'use strict' directive used here."),
|
|
Print_the_final_configuration_instead_of_building: diag(1350, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* Message */, "Convert_to_type_only_export_1364", "Convert to type-only export"),
|
|
Convert_all_re_exported_types_to_type_only_exports: diag(1365, 3 /* 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, 3 /* Message */, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"),
|
|
Split_all_invalid_type_only_imports: diag(1367, 3 /* Message */, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"),
|
|
Class_constructor_may_not_be_a_generator: diag(1368, 1 /* Error */, "Class_constructor_may_not_be_a_generator_1368", "Class constructor may not be a generator."),
|
|
Did_you_mean_0: diag(1369, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 3 /* Message */, "_0_was_imported_here_1376", "'{0}' was imported here."),
|
|
_0_was_exported_here: diag(1377, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"),
|
|
Unexpected_token_Did_you_mean_or_gt: diag(1382, 1 /* Error */, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"),
|
|
Only_named_exports_may_use_export_type: diag(1383, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"),
|
|
Imported_via_0_from_file_1: diag(1393, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "File_is_included_via_import_here_1399", "File is included via import here."),
|
|
Referenced_via_0_from_file_1: diag(1400, 3 /* Message */, "Referenced_via_0_from_file_1_1400", "Referenced via '{0}' from file '{1}'"),
|
|
File_is_included_via_reference_here: diag(1401, 3 /* Message */, "File_is_included_via_reference_here_1401", "File is included via reference here."),
|
|
Type_library_referenced_via_0_from_file_1: diag(1402, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Library_0_specified_in_compilerOptions_1422", "Library '{0}' specified in compilerOptions"),
|
|
File_is_library_specified_here: diag(1423, 3 /* Message */, "File_is_library_specified_here_1423", "File is library specified here."),
|
|
Default_library: diag(1424, 3 /* Message */, "Default_library_1424", "Default library"),
|
|
Default_library_for_target_0: diag(1425, 3 /* Message */, "Default_library_for_target_0_1425", "Default library for target '{0}'"),
|
|
File_is_default_library_for_target_specified_here: diag(1426, 3 /* 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, 3 /* Message */, "Root_file_specified_for_compilation_1427", "Root file specified for compilation"),
|
|
File_is_output_of_project_reference_source_0: diag(1428, 3 /* 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, 3 /* Message */, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"),
|
|
The_file_is_in_the_program_because_Colon: diag(1430, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Decorators_may_not_be_applied_to_this_parameters_1433", "Decorators may not be applied to 'this' parameters."),
|
|
Unexpected_keyword_or_identifier: diag(1434, 1 /* Error */, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."),
|
|
Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, 1 /* 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, 1 /* 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, 1 /* Error */, "Namespace_must_be_given_a_name_1437", "Namespace must be given a name."),
|
|
Interface_must_be_given_a_name: diag(1438, 1 /* Error */, "Interface_must_be_given_a_name_1438", "Interface must be given a name."),
|
|
Type_alias_must_be_given_a_name: diag(1439, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Expected_for_property_initializer_1442", "Expected '=' for property initializer."),
|
|
Module_declaration_names_may_only_use_or_quoted_strings: diag(1443, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", void 0, true),
|
|
Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, 1 /* Error */, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", void 0, true),
|
|
Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, 1 /* 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}'.", void 0, true),
|
|
Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, 1 /* 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}'.", void 0, true),
|
|
The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* Message */, "Add_extends_constraint_2211", "Add `extends` constraint."),
|
|
Add_extends_constraint_to_all_type_parameters: diag(2212, 3 /* Message */, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
|
|
Duplicate_identifier_0: diag(2300, 1 /* Error */, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
|
|
Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, 1 /* 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, 1 /* Error */, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
|
|
Circular_definition_of_import_alias_0: diag(2303, 1 /* Error */, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."),
|
|
Cannot_find_name_0: diag(2304, 1 /* Error */, "Cannot_find_name_0_2304", "Cannot find name '{0}'."),
|
|
Module_0_has_no_exported_member_1: diag(2305, 1 /* Error */, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."),
|
|
File_0_is_not_a_module: diag(2306, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."),
|
|
Global_type_0_must_be_a_class_or_interface_type: diag(2316, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."),
|
|
Property_0_is_missing_in_type_1: diag(2324, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Parameter_0_cannot_reference_itself_2372", "Parameter '{0}' cannot reference itself."),
|
|
Parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Function_overload_must_be_static_2387", "Function overload must be static."),
|
|
Function_overload_must_not_be_static: diag(2388, 1 /* Error */, "Function_overload_must_not_be_static_2388", "Function overload must not be static."),
|
|
Function_implementation_name_must_be_0: diag(2389, 1 /* Error */, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."),
|
|
Constructor_implementation_is_missing: diag(2390, 1 /* Error */, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."),
|
|
Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, 1 /* 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, 1 /* Error */, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."),
|
|
Duplicate_function_implementation: diag(2393, 1 /* Error */, "Duplicate_function_implementation_2393", "Duplicate function implementation."),
|
|
This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."),
|
|
Class_0_incorrectly_extends_base_class_1: diag(2415, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Types_of_construct_signatures_are_incompatible_2419", "Types of construct signatures are incompatible."),
|
|
Class_0_incorrectly_implements_interface_1: diag(2420, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."),
|
|
All_declarations_of_0_must_have_identical_type_parameters: diag(2428, 1 /* 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, 1 /* Error */, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."),
|
|
Enum_name_cannot_be_0: diag(2431, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."),
|
|
Enum_0_used_before_its_declaration: diag(2450, 1 /* Error */, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."),
|
|
Cannot_redeclare_block_scoped_variable_0: diag(2451, 1 /* Error */, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."),
|
|
An_enum_member_cannot_have_a_numeric_name: diag(2452, 1 /* 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, 1 /* Error */, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."),
|
|
Type_alias_0_circularly_references_itself: diag(2456, 1 /* Error */, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."),
|
|
Type_alias_name_cannot_be_0: diag(2457, 1 /* Error */, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."),
|
|
An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."),
|
|
The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, 1 /* 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, 1 /* 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, 1 /* Error */, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."),
|
|
const_enum_member_initializers_must_be_constant_expressions: diag(2474, 1 /* Error */, "const_enum_member_initializers_must_be_constant_expressions_2474", "const enum member initializers must be constant expressions."),
|
|
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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."),
|
|
Object_is_possibly_null: diag(2531, 1 /* Error */, "Object_is_possibly_null_2531", "Object is possibly 'null'."),
|
|
Object_is_possibly_undefined: diag(2532, 1 /* Error */, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."),
|
|
Object_is_possibly_null_or_undefined: diag(2533, 1 /* 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, 1 /* Error */, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."),
|
|
Type_0_cannot_be_used_to_index_type_1: diag(2536, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."),
|
|
Expected_at_least_0_arguments_but_got_1: diag(2555, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
|
|
A_rest_element_type_must_be_an_array_type: diag(2574, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."),
|
|
Unused_ts_expect_error_directive: diag(2578, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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.", true),
|
|
The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* Message */, "_0_is_declared_here_2728", "'{0}' is declared here."),
|
|
Property_0_is_used_before_its_initialization: diag(2729, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."),
|
|
Are_you_missing_a_semicolon: diag(2734, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."),
|
|
Circularity_originates_in_type_at_this_location: diag(2751, 1 /* Error */, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."),
|
|
The_first_export_default_is_here: diag(2752, 1 /* Error */, "The_first_export_default_is_here_2752", "The first export default is here."),
|
|
Another_export_default_is_here: diag(2753, 1 /* Error */, "Another_export_default_is_here_2753", "Another export default is here."),
|
|
super_may_not_use_type_arguments: diag(2754, 1 /* Error */, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."),
|
|
No_constituent_of_type_0_is_callable: diag(2755, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "No_overload_matches_this_call_2769", "No overload matches this call."),
|
|
The_last_overload_gave_the_following_error: diag(2770, 1 /* Error */, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."),
|
|
The_last_overload_is_declared_here: diag(2771, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "This_spread_always_overwrites_this_property_2785", "This spread always overwrites this property."),
|
|
_0_cannot_be_used_as_a_JSX_component: diag(2786, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "This_condition_will_always_return_0_2845", "This condition will always return '{0}'."),
|
|
Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."),
|
|
Tuple_type_arguments_circularly_reference_themselves: diag(4110, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."),
|
|
Failed_to_parse_file_0_Colon_1: diag(5014, 1 /* Error */, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."),
|
|
Unknown_compiler_option_0: diag(5023, 1 /* Error */, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."),
|
|
Compiler_option_0_requires_a_value_of_type_1: diag(5024, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Unknown_build_option_0_5072", "Unknown build option '{0}'."),
|
|
Build_option_0_requires_a_value_of_type_1: diag(5073, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"),
|
|
Unknown_watch_option_0: diag(5078, 1 /* Error */, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."),
|
|
Unknown_watch_option_0_Did_you_mean_1: diag(5079, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Cannot_read_file_0_5083", "Cannot read file '{0}'."),
|
|
Tuple_members_must_all_have_names_or_all_not_have_names: diag(5084, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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(6e3, 3 /* 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, 3 /* Message */, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."),
|
|
Generates_corresponding_d_ts_file: diag(6002, 3 /* 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, 3 /* 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, 3 /* Message */, "Watch_input_files_6005", "Watch input files."),
|
|
Redirect_output_structure_to_the_directory: diag(6006, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."),
|
|
Do_not_emit_outputs: diag(6010, 3 /* 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, 3 /* 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, 3 /* Message */, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."),
|
|
Do_not_resolve_the_real_path_of_symlinks: diag(6013, 3 /* 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, 3 /* Message */, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."),
|
|
Specify_ECMAScript_target_version: diag(6015, 3 /* Message */, "Specify_ECMAScript_target_version_6015", "Specify ECMAScript target version."),
|
|
Specify_module_code_generation: diag(6016, 3 /* Message */, "Specify_module_code_generation_6016", "Specify module code generation."),
|
|
Print_this_message: diag(6017, 3 /* Message */, "Print_this_message_6017", "Print this message."),
|
|
Print_the_compiler_s_version: diag(6019, 3 /* 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, 3 /* 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, 3 /* Message */, "Syntax_Colon_0_6023", "Syntax: {0}"),
|
|
options: diag(6024, 3 /* Message */, "options_6024", "options"),
|
|
file: diag(6025, 3 /* Message */, "file_6025", "file"),
|
|
Examples_Colon_0: diag(6026, 3 /* Message */, "Examples_Colon_0_6026", "Examples: {0}"),
|
|
Options_Colon: diag(6027, 3 /* Message */, "Options_Colon_6027", "Options:"),
|
|
Version_0: diag(6029, 3 /* Message */, "Version_0_6029", "Version {0}"),
|
|
Insert_command_line_options_and_files_from_a_file: diag(6030, 3 /* 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, 3 /* Message */, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."),
|
|
File_change_detected_Starting_incremental_compilation: diag(6032, 3 /* Message */, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."),
|
|
KIND: diag(6034, 3 /* Message */, "KIND_6034", "KIND"),
|
|
FILE: diag(6035, 3 /* Message */, "FILE_6035", "FILE"),
|
|
VERSION: diag(6036, 3 /* Message */, "VERSION_6036", "VERSION"),
|
|
LOCATION: diag(6037, 3 /* Message */, "LOCATION_6037", "LOCATION"),
|
|
DIRECTORY: diag(6038, 3 /* Message */, "DIRECTORY_6038", "DIRECTORY"),
|
|
STRATEGY: diag(6039, 3 /* Message */, "STRATEGY_6039", "STRATEGY"),
|
|
FILE_OR_DIRECTORY: diag(6040, 3 /* Message */, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"),
|
|
Errors_Files: diag(6041, 3 /* Message */, "Errors_Files_6041", "Errors Files"),
|
|
Generates_corresponding_map_file: diag(6043, 3 /* Message */, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."),
|
|
Compiler_option_0_expects_an_argument: diag(6044, 1 /* Error */, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."),
|
|
Unterminated_quoted_string_in_response_file_0: diag(6045, 1 /* 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, 1 /* 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, 1 /* Error */, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'."),
|
|
Unable_to_open_file_0: diag(6050, 1 /* Error */, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."),
|
|
Corrupted_locale_file_0: diag(6051, 1 /* Error */, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."),
|
|
Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, 3 /* 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, 1 /* Error */, "File_0_not_found_6053", "File '{0}' not found."),
|
|
File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* Message */, "NEWLINE_6061", "NEWLINE"),
|
|
Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: diag(6064, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."),
|
|
Suppress_excess_property_checks_for_object_literals: diag(6072, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Specify_JSX_code_generation_6080", "Specify JSX code generation."),
|
|
File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."),
|
|
Resolving_module_0_from_1: diag(6086, 3 /* Message */, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"),
|
|
Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."),
|
|
Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, 3 /* 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, 3 /* 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_types_Colon_1: diag(6095, 3 /* Message */, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1_6095", "Loading module as file / folder, candidate module location '{0}', target file types: {1}."),
|
|
File_0_does_not_exist: diag(6096, 3 /* Message */, "File_0_does_not_exist_6096", "File '{0}' does not exist."),
|
|
File_0_exist_use_it_as_a_name_resolution_result: diag(6097, 3 /* 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_types_Colon_1: diag(6098, 3 /* Message */, "Loading_module_0_from_node_modules_folder_target_file_types_Colon_1_6098", "Loading module '{0}' from 'node_modules' folder, target file types: {1}."),
|
|
Found_package_json_at_0: diag(6099, 3 /* Message */, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."),
|
|
package_json_does_not_have_a_0_field: diag(6100, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."),
|
|
Module_resolution_using_rootDirs_has_failed: diag(6111, 3 /* 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, 3 /* 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, 3 /* Message */, "Enable_strict_null_checks_6113", "Enable strict null checks."),
|
|
Unknown_option_excludes_Did_you_mean_exclude: diag(6114, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"),
|
|
Resolving_with_primary_search_path_0: diag(6121, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 3 /* 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, 1 /* Error */, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", true),
|
|
Report_errors_on_unused_locals: diag(6134, 3 /* Message */, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."),
|
|
Report_errors_on_unused_parameters: diag(6135, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* Error */, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", true),
|
|
Import_emit_helpers_from_tslib: diag(6139, 3 /* 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, 1 /* 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, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Show_diagnostic_information_6149", "Show diagnostic information."),
|
|
Show_verbose_diagnostic_information: diag(6150, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."),
|
|
The_character_set_of_the_input_files: diag(6163, 3 /* Message */, "The_character_set_of_the_input_files_6163", "The character set of the input files."),
|
|
Do_not_truncate_error_messages: diag(6165, 3 /* Message */, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."),
|
|
Output_directory_for_generated_declaration_files: diag(6166, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Show_all_compiler_options_6169", "Show all compiler options."),
|
|
Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."),
|
|
Scoped_package_detected_looking_in_0: diag(6182, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."),
|
|
Enable_strict_checking_of_property_initialization_in_classes: diag(6187, 3 /* 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, 1 /* Error */, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."),
|
|
Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, 1 /* 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, 3 /* 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, 1 /* Error */, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", true),
|
|
Found_1_error_Watching_for_file_changes: diag(6193, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* Error */, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", true),
|
|
Include_modules_imported_with_json_extension: diag(6197, 3 /* Message */, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"),
|
|
All_destructured_elements_are_unused: diag(6198, 1 /* Error */, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", true),
|
|
All_variables_are_unused: diag(6199, 1 /* Error */, "All_variables_are_unused_6199", "All variables are unused.", true),
|
|
Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, 1 /* 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, 3 /* 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, 1 /* 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, 3 /* Message */, "_0_was_also_declared_here_6203", "'{0}' was also declared here."),
|
|
and_here: diag(6204, 3 /* Message */, "and_here_6204", "and here."),
|
|
All_type_parameters_are_unused: diag(6205, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."),
|
|
Found_1_error: diag(6216, 3 /* Message */, "Found_1_error_6216", "Found 1 error."),
|
|
Found_0_errors: diag(6217, 3 /* Message */, "Found_0_errors_6217", "Found {0} errors."),
|
|
Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: diag(6218, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."),
|
|
Generates_a_CPU_profile: diag(6223, 3 /* Message */, "Generates_a_CPU_profile_6223", "Generates a CPU profile."),
|
|
Disable_solution_searching_for_this_project: diag(6224, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* Message */, "Disable_loading_referenced_projects_6235", "Disable loading referenced projects."),
|
|
Arguments_for_the_rest_parameter_0_were_not_provided: diag(6236, 1 /* 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, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Modules_6244", "Modules"),
|
|
File_Management: diag(6245, 3 /* Message */, "File_Management_6245", "File Management"),
|
|
Emit: diag(6246, 3 /* Message */, "Emit_6246", "Emit"),
|
|
JavaScript_Support: diag(6247, 3 /* Message */, "JavaScript_Support_6247", "JavaScript Support"),
|
|
Type_Checking: diag(6248, 3 /* Message */, "Type_Checking_6248", "Type Checking"),
|
|
Editor_Support: diag(6249, 3 /* Message */, "Editor_Support_6249", "Editor Support"),
|
|
Watch_and_Build_Modes: diag(6250, 3 /* Message */, "Watch_and_Build_Modes_6250", "Watch and Build Modes"),
|
|
Compiler_Diagnostics: diag(6251, 3 /* Message */, "Compiler_Diagnostics_6251", "Compiler Diagnostics"),
|
|
Interop_Constraints: diag(6252, 3 /* Message */, "Interop_Constraints_6252", "Interop Constraints"),
|
|
Backwards_Compatibility: diag(6253, 3 /* Message */, "Backwards_Compatibility_6253", "Backwards Compatibility"),
|
|
Language_and_Environment: diag(6254, 3 /* Message */, "Language_and_Environment_6254", "Language and Environment"),
|
|
Projects: diag(6255, 3 /* Message */, "Projects_6255", "Projects"),
|
|
Output_Formatting: diag(6256, 3 /* Message */, "Output_Formatting_6256", "Output Formatting"),
|
|
Completeness: diag(6257, 3 /* Message */, "Completeness_6257", "Completeness"),
|
|
_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Enable_project_compilation_6302", "Enable project compilation"),
|
|
Composite_projects_may_not_disable_declaration_emit: diag(6304, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"),
|
|
Building_project_0: diag(6358, 3 /* Message */, "Building_project_0_6358", "Building project '{0}'..."),
|
|
Updating_output_timestamps_of_project_0: diag(6359, 3 /* Message */, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."),
|
|
Project_0_is_up_to_date: diag(6361, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 2 /* Suggestion */, "_0_is_deprecated_6385", "'{0}' is deprecated.", void 0, void 0, 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, 3 /* 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, 2 /* Suggestion */, "The_signature_0_of_1_is_deprecated_6387", "The signature '{0}' of '{1}' is deprecated.", void 0, void 0, true),
|
|
Project_0_is_being_forcibly_rebuilt: diag(6388, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Resolving_in_0_mode_with_conditions_1_6402", "Resolving in {0} mode with conditions {1}."),
|
|
Matched_0_condition_1: diag(6403, 3 /* Message */, "Matched_0_condition_1_6403", "Matched '{0}' condition '{1}'."),
|
|
Using_0_subpath_1_with_target_2: diag(6404, 3 /* Message */, "Using_0_subpath_1_with_target_2_6404", "Using '{0}' subpath '{1}' with target '{2}'."),
|
|
Saw_non_matching_condition_0: diag(6405, 3 /* Message */, "Saw_non_matching_condition_0_6405", "Saw non-matching condition '{0}'."),
|
|
Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions: diag(6406, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions_6406", "Project '{0}' is out of date because buildinfo file '{1}' indicates there is change in compilerOptions"),
|
|
The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Allow_accessing_UMD_globals_from_modules_6602", "Allow accessing UMD globals from modules."),
|
|
Disable_error_reporting_for_unreachable_code: diag(6603, 3 /* Message */, "Disable_error_reporting_for_unreachable_code_6603", "Disable error reporting for unreachable code."),
|
|
Disable_error_reporting_for_unused_labels: diag(6604, 3 /* Message */, "Disable_error_reporting_for_unused_labels_6604", "Disable error reporting for unused labels."),
|
|
Ensure_use_strict_is_always_emitted: diag(6605, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Create_sourcemaps_for_d_ts_files_6614", "Create sourcemaps for d.ts files."),
|
|
Output_compiler_performance_information_after_building: diag(6615, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Set_the_newline_character_for_emitting_files_6659", "Set the newline character for emitting files."),
|
|
Disable_emitting_files_from_a_compilation: diag(6660, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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 '<reference>'s from expanding the number of files TypeScript should add to a project."),
|
|
Disable_strict_checking_of_generic_signatures_in_function_types: diag(6673, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Deprecated_setting_Use_outFile_instead_6677", "Deprecated setting. Use 'outFile' instead."),
|
|
Specify_an_output_folder_for_all_emitted_files: diag(6678, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Disable_emitting_comments_6688", "Disable emitting comments."),
|
|
Enable_importing_json_files: diag(6689, 3 /* Message */, "Enable_importing_json_files_6689", "Enable importing .json files."),
|
|
Specify_the_root_folder_within_your_source_files: diag(6690, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Emit_ECMAScript_standard_compliant_class_fields_6712", "Emit ECMAScript-standard-compliant class fields."),
|
|
Enable_verbose_logging: diag(6713, 3 /* Message */, "Enable_verbose_logging_6713", "Enable verbose logging."),
|
|
Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality: diag(6714, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "one_of_Colon_6900", "one of:"),
|
|
one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
|
|
type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
|
|
default_Colon: diag(6903, 3 /* Message */, "default_Colon_6903", "default:"),
|
|
module_system_or_esModuleInterop: diag(6904, 3 /* Message */, "module_system_or_esModuleInterop_6904", 'module === "system" or esModuleInterop'),
|
|
false_unless_strict_is_set: diag(6905, 3 /* Message */, "false_unless_strict_is_set_6905", "`false`, unless `strict` is set"),
|
|
false_unless_composite_is_set: diag(6906, 3 /* 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, 3 /* 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, 3 /* Message */, "if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk_6908", '`[]` if `files` is specified, otherwise `["**/*"]`'),
|
|
true_if_composite_false_otherwise: diag(6909, 3 /* 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, 3 /* 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, 3 /* Message */, "Computed_from_the_list_of_input_files_6911", "Computed from the list of input files"),
|
|
Platform_specific: diag(6912, 3 /* Message */, "Platform_specific_6912", "Platform specific"),
|
|
You_can_learn_about_all_of_the_compiler_options_at_0: diag(6913, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "COMMON_COMMANDS_6916", "COMMON COMMANDS"),
|
|
ALL_COMPILER_OPTIONS: diag(6917, 3 /* Message */, "ALL_COMPILER_OPTIONS_6917", "ALL COMPILER OPTIONS"),
|
|
WATCH_OPTIONS: diag(6918, 3 /* Message */, "WATCH_OPTIONS_6918", "WATCH OPTIONS"),
|
|
BUILD_OPTIONS: diag(6919, 3 /* Message */, "BUILD_OPTIONS_6919", "BUILD OPTIONS"),
|
|
COMMON_COMPILER_OPTIONS: diag(6920, 3 /* Message */, "COMMON_COMPILER_OPTIONS_6920", "COMMON COMPILER OPTIONS"),
|
|
COMMAND_LINE_FLAGS: diag(6921, 3 /* Message */, "COMMAND_LINE_FLAGS_6921", "COMMAND LINE FLAGS"),
|
|
tsc_Colon_The_TypeScript_Compiler: diag(6922, 3 /* Message */, "tsc_Colon_The_TypeScript_Compiler_6922", "tsc: The TypeScript Compiler"),
|
|
Compiles_the_current_project_tsconfig_json_in_the_working_directory: diag(6923, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Unreachable_code_detected_7027", "Unreachable code detected.", true),
|
|
Unused_label: diag(7028, 1 /* Error */, "Unused_label_7028", "Unused label.", true),
|
|
Fallthrough_case_in_switch: diag(7029, 1 /* Error */, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."),
|
|
Not_all_code_paths_return_a_value: diag(7030, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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(8e3, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* Message */, "Report_errors_in_js_files_8019", "Report errors in .js files."),
|
|
JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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(17e3, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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(18e3, 1 /* 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, 1 /* 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, 1 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 2 /* 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, 3 /* Message */, "Add_missing_super_call_90001", "Add missing 'super()' call"),
|
|
Make_super_call_the_first_statement_in_the_constructor: diag(90002, 3 /* 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, 3 /* Message */, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
|
|
Remove_unused_declaration_for_Colon_0: diag(90004, 3 /* Message */, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"),
|
|
Remove_import_from_0: diag(90005, 3 /* Message */, "Remove_import_from_0_90005", "Remove import from '{0}'"),
|
|
Implement_interface_0: diag(90006, 3 /* Message */, "Implement_interface_0_90006", "Implement interface '{0}'"),
|
|
Implement_inherited_abstract_class: diag(90007, 3 /* Message */, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"),
|
|
Add_0_to_unresolved_variable: diag(90008, 3 /* Message */, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"),
|
|
Remove_variable_statement: diag(90010, 3 /* Message */, "Remove_variable_statement_90010", "Remove variable statement"),
|
|
Remove_template_tag: diag(90011, 3 /* Message */, "Remove_template_tag_90011", "Remove template tag"),
|
|
Remove_type_parameters: diag(90012, 3 /* Message */, "Remove_type_parameters_90012", "Remove type parameters"),
|
|
Import_0_from_1: diag(90013, 3 /* Message */, "Import_0_from_1_90013", `Import '{0}' from "{1}"`),
|
|
Change_0_to_1: diag(90014, 3 /* Message */, "Change_0_to_1_90014", "Change '{0}' to '{1}'"),
|
|
Declare_property_0: diag(90016, 3 /* Message */, "Declare_property_0_90016", "Declare property '{0}'"),
|
|
Add_index_signature_for_property_0: diag(90017, 3 /* Message */, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"),
|
|
Disable_checking_for_this_file: diag(90018, 3 /* Message */, "Disable_checking_for_this_file_90018", "Disable checking for this file"),
|
|
Ignore_this_error_message: diag(90019, 3 /* Message */, "Ignore_this_error_message_90019", "Ignore this error message"),
|
|
Initialize_property_0_in_the_constructor: diag(90020, 3 /* Message */, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"),
|
|
Initialize_static_property_0: diag(90021, 3 /* Message */, "Initialize_static_property_0_90021", "Initialize static property '{0}'"),
|
|
Change_spelling_to_0: diag(90022, 3 /* Message */, "Change_spelling_to_0_90022", "Change spelling to '{0}'"),
|
|
Declare_method_0: diag(90023, 3 /* Message */, "Declare_method_0_90023", "Declare method '{0}'"),
|
|
Declare_static_method_0: diag(90024, 3 /* Message */, "Declare_static_method_0_90024", "Declare static method '{0}'"),
|
|
Prefix_0_with_an_underscore: diag(90025, 3 /* Message */, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"),
|
|
Rewrite_as_the_indexed_access_type_0: diag(90026, 3 /* Message */, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"),
|
|
Declare_static_property_0: diag(90027, 3 /* Message */, "Declare_static_property_0_90027", "Declare static property '{0}'"),
|
|
Call_decorator_expression: diag(90028, 3 /* Message */, "Call_decorator_expression_90028", "Call decorator expression"),
|
|
Add_async_modifier_to_containing_function: diag(90029, 3 /* Message */, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"),
|
|
Replace_infer_0_with_unknown: diag(90030, 3 /* Message */, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"),
|
|
Replace_all_unused_infer_with_unknown: diag(90031, 3 /* Message */, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"),
|
|
Add_parameter_name: diag(90034, 3 /* Message */, "Add_parameter_name_90034", "Add parameter name"),
|
|
Declare_private_property_0: diag(90035, 3 /* Message */, "Declare_private_property_0_90035", "Declare private property '{0}'"),
|
|
Replace_0_with_Promise_1: diag(90036, 3 /* Message */, "Replace_0_with_Promise_1_90036", "Replace '{0}' with 'Promise<{1}>'"),
|
|
Fix_all_incorrect_return_type_of_an_async_functions: diag(90037, 3 /* 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, 3 /* Message */, "Declare_private_method_0_90038", "Declare private method '{0}'"),
|
|
Remove_unused_destructuring_declaration: diag(90039, 3 /* Message */, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"),
|
|
Remove_unused_declarations_for_Colon_0: diag(90041, 3 /* Message */, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
|
|
Declare_a_private_field_named_0: diag(90053, 3 /* Message */, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
|
|
Includes_imports_of_types_referenced_by_0: diag(90054, 3 /* 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, 3 /* 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, 3 /* Message */, "Remove_type_from_import_of_0_from_1_90056", `Remove 'type' from import of '{0}' from "{1}"`),
|
|
Add_import_from_0: diag(90057, 3 /* Message */, "Add_import_from_0_90057", 'Add import from "{0}"'),
|
|
Update_import_from_0: diag(90058, 3 /* Message */, "Update_import_from_0_90058", 'Update import from "{0}"'),
|
|
Export_0_from_module_1: diag(90059, 3 /* Message */, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
|
|
Export_all_referenced_locals: diag(90060, 3 /* Message */, "Export_all_referenced_locals_90060", "Export all referenced locals"),
|
|
Convert_function_to_an_ES2015_class: diag(95001, 3 /* Message */, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
|
|
Convert_0_to_1_in_0: diag(95003, 3 /* Message */, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
|
|
Extract_to_0_in_1: diag(95004, 3 /* Message */, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
|
|
Extract_function: diag(95005, 3 /* Message */, "Extract_function_95005", "Extract function"),
|
|
Extract_constant: diag(95006, 3 /* Message */, "Extract_constant_95006", "Extract constant"),
|
|
Extract_to_0_in_enclosing_scope: diag(95007, 3 /* Message */, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"),
|
|
Extract_to_0_in_1_scope: diag(95008, 3 /* Message */, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"),
|
|
Annotate_with_type_from_JSDoc: diag(95009, 3 /* Message */, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"),
|
|
Infer_type_of_0_from_usage: diag(95011, 3 /* Message */, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"),
|
|
Infer_parameter_types_from_usage: diag(95012, 3 /* Message */, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"),
|
|
Convert_to_default_import: diag(95013, 3 /* Message */, "Convert_to_default_import_95013", "Convert to default import"),
|
|
Install_0: diag(95014, 3 /* Message */, "Install_0_95014", "Install '{0}'"),
|
|
Replace_import_with_0: diag(95015, 3 /* Message */, "Replace_import_with_0_95015", "Replace import with '{0}'."),
|
|
Use_synthetic_default_member: diag(95016, 3 /* Message */, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."),
|
|
Convert_to_ES_module: diag(95017, 3 /* Message */, "Convert_to_ES_module_95017", "Convert to ES module"),
|
|
Add_undefined_type_to_property_0: diag(95018, 3 /* Message */, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"),
|
|
Add_initializer_to_property_0: diag(95019, 3 /* Message */, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"),
|
|
Add_definite_assignment_assertion_to_property_0: diag(95020, 3 /* 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, 3 /* Message */, "Convert_all_type_literals_to_mapped_type_95021", "Convert all type literals to mapped type"),
|
|
Add_all_missing_members: diag(95022, 3 /* Message */, "Add_all_missing_members_95022", "Add all missing members"),
|
|
Infer_all_types_from_usage: diag(95023, 3 /* Message */, "Infer_all_types_from_usage_95023", "Infer all types from usage"),
|
|
Delete_all_unused_declarations: diag(95024, 3 /* Message */, "Delete_all_unused_declarations_95024", "Delete all unused declarations"),
|
|
Prefix_all_unused_declarations_with_where_possible: diag(95025, 3 /* Message */, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"),
|
|
Fix_all_detected_spelling_errors: diag(95026, 3 /* Message */, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"),
|
|
Add_initializers_to_all_uninitialized_properties: diag(95027, 3 /* Message */, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"),
|
|
Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"),
|
|
Install_all_missing_types_packages: diag(95033, 3 /* Message */, "Install_all_missing_types_packages_95033", "Install all missing types packages"),
|
|
Rewrite_all_as_indexed_access_types: diag(95034, 3 /* Message */, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"),
|
|
Convert_all_to_default_imports: diag(95035, 3 /* Message */, "Convert_all_to_default_imports_95035", "Convert all to default imports"),
|
|
Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, 3 /* 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, 3 /* 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, 3 /* Message */, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"),
|
|
Add_all_missing_super_calls: diag(95039, 3 /* Message */, "Add_all_missing_super_calls_95039", "Add all missing super calls"),
|
|
Implement_all_inherited_abstract_classes: diag(95040, 3 /* Message */, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"),
|
|
Add_all_missing_async_modifiers: diag(95041, 3 /* Message */, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"),
|
|
Add_ts_ignore_to_all_error_messages: diag(95042, 3 /* Message */, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"),
|
|
Annotate_everything_with_types_from_JSDoc: diag(95043, 3 /* Message */, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"),
|
|
Add_to_all_uncalled_decorators: diag(95044, 3 /* Message */, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"),
|
|
Convert_all_constructor_functions_to_classes: diag(95045, 3 /* Message */, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"),
|
|
Generate_get_and_set_accessors: diag(95046, 3 /* Message */, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"),
|
|
Convert_require_to_import: diag(95047, 3 /* Message */, "Convert_require_to_import_95047", "Convert 'require' to 'import'"),
|
|
Convert_all_require_to_import: diag(95048, 3 /* Message */, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"),
|
|
Move_to_a_new_file: diag(95049, 3 /* Message */, "Move_to_a_new_file_95049", "Move to a new file"),
|
|
Remove_unreachable_code: diag(95050, 3 /* Message */, "Remove_unreachable_code_95050", "Remove unreachable code"),
|
|
Remove_all_unreachable_code: diag(95051, 3 /* Message */, "Remove_all_unreachable_code_95051", "Remove all unreachable code"),
|
|
Add_missing_typeof: diag(95052, 3 /* Message */, "Add_missing_typeof_95052", "Add missing 'typeof'"),
|
|
Remove_unused_label: diag(95053, 3 /* Message */, "Remove_unused_label_95053", "Remove unused label"),
|
|
Remove_all_unused_labels: diag(95054, 3 /* Message */, "Remove_all_unused_labels_95054", "Remove all unused labels"),
|
|
Convert_0_to_mapped_object_type: diag(95055, 3 /* Message */, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"),
|
|
Convert_namespace_import_to_named_imports: diag(95056, 3 /* Message */, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"),
|
|
Convert_named_imports_to_namespace_import: diag(95057, 3 /* Message */, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"),
|
|
Add_or_remove_braces_in_an_arrow_function: diag(95058, 3 /* 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, 3 /* Message */, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"),
|
|
Remove_braces_from_arrow_function: diag(95060, 3 /* Message */, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"),
|
|
Convert_default_export_to_named_export: diag(95061, 3 /* Message */, "Convert_default_export_to_named_export_95061", "Convert default export to named export"),
|
|
Convert_named_export_to_default_export: diag(95062, 3 /* Message */, "Convert_named_export_to_default_export_95062", "Convert named export to default export"),
|
|
Add_missing_enum_member_0: diag(95063, 3 /* Message */, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"),
|
|
Add_all_missing_imports: diag(95064, 3 /* Message */, "Add_all_missing_imports_95064", "Add all missing imports"),
|
|
Convert_to_async_function: diag(95065, 3 /* Message */, "Convert_to_async_function_95065", "Convert to async function"),
|
|
Convert_all_to_async_functions: diag(95066, 3 /* Message */, "Convert_all_to_async_functions_95066", "Convert all to async functions"),
|
|
Add_missing_call_parentheses: diag(95067, 3 /* Message */, "Add_missing_call_parentheses_95067", "Add missing call parentheses"),
|
|
Add_all_missing_call_parentheses: diag(95068, 3 /* Message */, "Add_all_missing_call_parentheses_95068", "Add all missing call parentheses"),
|
|
Add_unknown_conversion_for_non_overlapping_types: diag(95069, 3 /* 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, 3 /* 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, 3 /* Message */, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"),
|
|
Add_missing_new_operator_to_all_calls: diag(95072, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"),
|
|
Extract_type: diag(95077, 3 /* Message */, "Extract_type_95077", "Extract type"),
|
|
Extract_to_type_alias: diag(95078, 3 /* Message */, "Extract_to_type_alias_95078", "Extract to type alias"),
|
|
Extract_to_typedef: diag(95079, 3 /* Message */, "Extract_to_typedef_95079", "Extract to typedef"),
|
|
Infer_this_type_of_0_from_usage: diag(95080, 3 /* Message */, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"),
|
|
Add_const_to_unresolved_variable: diag(95081, 3 /* Message */, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"),
|
|
Add_const_to_all_unresolved_variables: diag(95082, 3 /* Message */, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"),
|
|
Add_await: diag(95083, 3 /* Message */, "Add_await_95083", "Add 'await'"),
|
|
Add_await_to_initializer_for_0: diag(95084, 3 /* Message */, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"),
|
|
Fix_all_expressions_possibly_missing_await: diag(95085, 3 /* Message */, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"),
|
|
Remove_unnecessary_await: diag(95086, 3 /* Message */, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"),
|
|
Remove_all_unnecessary_uses_of_await: diag(95087, 3 /* Message */, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"),
|
|
Enable_the_jsx_flag_in_your_configuration_file: diag(95088, 3 /* Message */, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"),
|
|
Add_await_to_initializers: diag(95089, 3 /* Message */, "Add_await_to_initializers_95089", "Add 'await' to initializers"),
|
|
Extract_to_interface: diag(95090, 3 /* Message */, "Extract_to_interface_95090", "Extract to interface"),
|
|
Convert_to_a_bigint_numeric_literal: diag(95091, 3 /* Message */, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"),
|
|
Convert_all_to_bigint_numeric_literals: diag(95092, 3 /* Message */, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"),
|
|
Convert_const_to_let: diag(95093, 3 /* Message */, "Convert_const_to_let_95093", "Convert 'const' to 'let'"),
|
|
Prefix_with_declare: diag(95094, 3 /* Message */, "Prefix_with_declare_95094", "Prefix with 'declare'"),
|
|
Prefix_all_incorrect_property_declarations_with_declare: diag(95095, 3 /* Message */, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"),
|
|
Convert_to_template_string: diag(95096, 3 /* Message */, "Convert_to_template_string_95096", "Convert to template string"),
|
|
Add_export_to_make_this_file_into_a_module: diag(95097, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Convert_all_const_to_let_95102", "Convert all 'const' to 'let'"),
|
|
Convert_function_expression_0_to_arrow_function: diag(95105, 3 /* 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, 3 /* Message */, "Convert_function_declaration_0_to_arrow_function_95106", "Convert function declaration '{0}' to arrow function"),
|
|
Fix_all_implicit_this_errors: diag(95107, 3 /* Message */, "Fix_all_implicit_this_errors_95107", "Fix all implicit-'this' errors"),
|
|
Wrap_invalid_character_in_an_expression_container: diag(95108, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Add_a_return_statement_95111", "Add a return statement"),
|
|
Remove_braces_from_arrow_function_body: diag(95112, 3 /* 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, 3 /* 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, 3 /* Message */, "Add_all_missing_return_statement_95114", "Add all missing return statement"),
|
|
Remove_braces_from_all_arrow_function_bodies_with_relevant_issues: diag(95115, 3 /* 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, 3 /* Message */, "Wrap_all_object_literal_with_parentheses_95116", "Wrap all object literal with parentheses"),
|
|
Move_labeled_tuple_element_modifiers_to_labels: diag(95117, 3 /* Message */, "Move_labeled_tuple_element_modifiers_to_labels_95117", "Move labeled tuple element modifiers to labels"),
|
|
Convert_overload_list_to_single_signature: diag(95118, 3 /* 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, 3 /* 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, 3 /* Message */, "Wrap_in_JSX_fragment_95120", "Wrap in JSX fragment"),
|
|
Wrap_all_unparented_JSX_in_JSX_fragment: diag(95121, 3 /* Message */, "Wrap_all_unparented_JSX_in_JSX_fragment_95121", "Wrap all unparented JSX in JSX fragment"),
|
|
Convert_arrow_function_or_function_expression: diag(95122, 3 /* Message */, "Convert_arrow_function_or_function_expression_95122", "Convert arrow function or function expression"),
|
|
Convert_to_anonymous_function: diag(95123, 3 /* Message */, "Convert_to_anonymous_function_95123", "Convert to anonymous function"),
|
|
Convert_to_named_function: diag(95124, 3 /* Message */, "Convert_to_named_function_95124", "Convert to named function"),
|
|
Convert_to_arrow_function: diag(95125, 3 /* Message */, "Convert_to_arrow_function_95125", "Convert to arrow function"),
|
|
Remove_parentheses: diag(95126, 3 /* Message */, "Remove_parentheses_95126", "Remove parentheses"),
|
|
Could_not_find_a_containing_arrow_function: diag(95127, 3 /* 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, 3 /* Message */, "Containing_function_is_not_an_arrow_function_95128", "Containing function is not an arrow function"),
|
|
Could_not_find_export_statement: diag(95129, 3 /* Message */, "Could_not_find_export_statement_95129", "Could not find export statement"),
|
|
This_file_already_has_a_default_export: diag(95130, 3 /* Message */, "This_file_already_has_a_default_export_95130", "This file already has a default export"),
|
|
Could_not_find_import_clause: diag(95131, 3 /* Message */, "Could_not_find_import_clause_95131", "Could not find import clause"),
|
|
Could_not_find_namespace_import_or_named_imports: diag(95132, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Name_is_not_valid_95136", "Name is not valid"),
|
|
Can_only_convert_property_with_modifier: diag(95137, 3 /* Message */, "Can_only_convert_property_with_modifier_95137", "Can only convert property with modifier"),
|
|
Switch_each_misused_0_to_1: diag(95138, 3 /* Message */, "Switch_each_misused_0_to_1_95138", "Switch each misused '{0}' to '{1}'"),
|
|
Convert_to_optional_chain_expression: diag(95139, 3 /* Message */, "Convert_to_optional_chain_expression_95139", "Convert to optional chain expression"),
|
|
Could_not_find_convertible_access_expression: diag(95140, 3 /* Message */, "Could_not_find_convertible_access_expression_95140", "Could not find convertible access expression"),
|
|
Could_not_find_matching_access_expressions: diag(95141, 3 /* Message */, "Could_not_find_matching_access_expressions_95141", "Could not find matching access expressions"),
|
|
Can_only_convert_logical_AND_access_chains: diag(95142, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Use_element_access_for_0_95145", "Use element access for '{0}'"),
|
|
Use_element_access_for_all_undeclared_properties: diag(95146, 3 /* Message */, "Use_element_access_for_all_undeclared_properties_95146", "Use element access for all undeclared properties."),
|
|
Delete_all_unused_imports: diag(95147, 3 /* Message */, "Delete_all_unused_imports_95147", "Delete all unused imports"),
|
|
Infer_function_return_type: diag(95148, 3 /* Message */, "Infer_function_return_type_95148", "Infer function return type"),
|
|
Return_type_must_be_inferred_from_a_function: diag(95149, 3 /* 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, 3 /* Message */, "Could_not_determine_function_return_type_95150", "Could not determine function return type"),
|
|
Could_not_convert_to_arrow_function: diag(95151, 3 /* Message */, "Could_not_convert_to_arrow_function_95151", "Could not convert to arrow function"),
|
|
Could_not_convert_to_named_function: diag(95152, 3 /* Message */, "Could_not_convert_to_named_function_95152", "Could not convert to named function"),
|
|
Could_not_convert_to_anonymous_function: diag(95153, 3 /* Message */, "Could_not_convert_to_anonymous_function_95153", "Could not convert to anonymous function"),
|
|
Can_only_convert_string_concatenation: diag(95154, 3 /* Message */, "Can_only_convert_string_concatenation_95154", "Can only convert string concatenation"),
|
|
Selection_is_not_a_valid_statement_or_statements: diag(95155, 3 /* 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, 3 /* Message */, "Add_missing_function_declaration_0_95156", "Add missing function declaration '{0}'"),
|
|
Add_all_missing_function_declarations: diag(95157, 3 /* Message */, "Add_all_missing_function_declarations_95157", "Add all missing function declarations"),
|
|
Method_not_implemented: diag(95158, 3 /* Message */, "Method_not_implemented_95158", "Method not implemented."),
|
|
Function_not_implemented: diag(95159, 3 /* Message */, "Function_not_implemented_95159", "Function not implemented."),
|
|
Add_override_modifier: diag(95160, 3 /* Message */, "Add_override_modifier_95160", "Add 'override' modifier"),
|
|
Remove_override_modifier: diag(95161, 3 /* Message */, "Remove_override_modifier_95161", "Remove 'override' modifier"),
|
|
Add_all_missing_override_modifiers: diag(95162, 3 /* Message */, "Add_all_missing_override_modifiers_95162", "Add all missing 'override' modifiers"),
|
|
Remove_all_unnecessary_override_modifiers: diag(95163, 3 /* Message */, "Remove_all_unnecessary_override_modifiers_95163", "Remove all unnecessary 'override' modifiers"),
|
|
Can_only_convert_named_export: diag(95164, 3 /* Message */, "Can_only_convert_named_export_95164", "Can only convert named export"),
|
|
Add_missing_properties: diag(95165, 3 /* Message */, "Add_missing_properties_95165", "Add missing properties"),
|
|
Add_all_missing_properties: diag(95166, 3 /* Message */, "Add_all_missing_properties_95166", "Add all missing properties"),
|
|
Add_missing_attributes: diag(95167, 3 /* Message */, "Add_missing_attributes_95167", "Add missing attributes"),
|
|
Add_all_missing_attributes: diag(95168, 3 /* Message */, "Add_all_missing_attributes_95168", "Add all missing attributes"),
|
|
Add_undefined_to_optional_property_type: diag(95169, 3 /* Message */, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
|
|
Convert_named_imports_to_default_import: diag(95170, 3 /* Message */, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
|
|
Delete_unused_param_tag_0: diag(95171, 3 /* Message */, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"),
|
|
Delete_all_unused_param_tags: diag(95172, 3 /* Message */, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"),
|
|
Rename_param_tag_name_0_to_1: diag(95173, 3 /* Message */, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
|
|
Use_0: diag(95174, 3 /* Message */, "Use_0_95174", "Use `{0}`."),
|
|
Use_Number_isNaN_in_all_conditions: diag(95175, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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."),
|
|
Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values: diag(18033, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values_18033", "Type '{0}' is not assignable to type '{1}' as required for computed enum member values."),
|
|
Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, 3 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 3 /* 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, 1 /* 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, 1 /* Error */, "_0_is_of_type_unknown_18046", "'{0}' is of type 'unknown'."),
|
|
_0_is_possibly_null: diag(18047, 1 /* Error */, "_0_is_possibly_null_18047", "'{0}' is possibly 'null'."),
|
|
_0_is_possibly_undefined: diag(18048, 1 /* Error */, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."),
|
|
_0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
|
|
The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here.")
|
|
};
|
|
|
|
// src/compiler/scanner.ts
|
|
function tokenIsIdentifierOrKeyword(token) {
|
|
return token >= 79 /* Identifier */;
|
|
}
|
|
function tokenIsIdentifierOrKeywordOrGreaterThan(token) {
|
|
return token === 31 /* GreaterThanToken */ || tokenIsIdentifierOrKeyword(token);
|
|
}
|
|
var textToKeywordObj = {
|
|
abstract: 126 /* AbstractKeyword */,
|
|
accessor: 127 /* AccessorKeyword */,
|
|
any: 131 /* AnyKeyword */,
|
|
as: 128 /* AsKeyword */,
|
|
asserts: 129 /* AssertsKeyword */,
|
|
assert: 130 /* AssertKeyword */,
|
|
bigint: 160 /* BigIntKeyword */,
|
|
boolean: 134 /* BooleanKeyword */,
|
|
break: 81 /* BreakKeyword */,
|
|
case: 82 /* CaseKeyword */,
|
|
catch: 83 /* CatchKeyword */,
|
|
class: 84 /* ClassKeyword */,
|
|
continue: 86 /* ContinueKeyword */,
|
|
const: 85 /* ConstKeyword */,
|
|
["constructor"]: 135 /* ConstructorKeyword */,
|
|
debugger: 87 /* DebuggerKeyword */,
|
|
declare: 136 /* DeclareKeyword */,
|
|
default: 88 /* DefaultKeyword */,
|
|
delete: 89 /* DeleteKeyword */,
|
|
do: 90 /* DoKeyword */,
|
|
else: 91 /* ElseKeyword */,
|
|
enum: 92 /* EnumKeyword */,
|
|
export: 93 /* ExportKeyword */,
|
|
extends: 94 /* ExtendsKeyword */,
|
|
false: 95 /* FalseKeyword */,
|
|
finally: 96 /* FinallyKeyword */,
|
|
for: 97 /* ForKeyword */,
|
|
from: 158 /* FromKeyword */,
|
|
function: 98 /* FunctionKeyword */,
|
|
get: 137 /* GetKeyword */,
|
|
if: 99 /* IfKeyword */,
|
|
implements: 117 /* ImplementsKeyword */,
|
|
import: 100 /* ImportKeyword */,
|
|
in: 101 /* InKeyword */,
|
|
infer: 138 /* InferKeyword */,
|
|
instanceof: 102 /* InstanceOfKeyword */,
|
|
interface: 118 /* InterfaceKeyword */,
|
|
intrinsic: 139 /* IntrinsicKeyword */,
|
|
is: 140 /* IsKeyword */,
|
|
keyof: 141 /* KeyOfKeyword */,
|
|
let: 119 /* LetKeyword */,
|
|
module: 142 /* ModuleKeyword */,
|
|
namespace: 143 /* NamespaceKeyword */,
|
|
never: 144 /* NeverKeyword */,
|
|
new: 103 /* NewKeyword */,
|
|
null: 104 /* NullKeyword */,
|
|
number: 148 /* NumberKeyword */,
|
|
object: 149 /* ObjectKeyword */,
|
|
package: 120 /* PackageKeyword */,
|
|
private: 121 /* PrivateKeyword */,
|
|
protected: 122 /* ProtectedKeyword */,
|
|
public: 123 /* PublicKeyword */,
|
|
override: 161 /* OverrideKeyword */,
|
|
out: 145 /* OutKeyword */,
|
|
readonly: 146 /* ReadonlyKeyword */,
|
|
require: 147 /* RequireKeyword */,
|
|
global: 159 /* GlobalKeyword */,
|
|
return: 105 /* ReturnKeyword */,
|
|
satisfies: 150 /* SatisfiesKeyword */,
|
|
set: 151 /* SetKeyword */,
|
|
static: 124 /* StaticKeyword */,
|
|
string: 152 /* StringKeyword */,
|
|
super: 106 /* SuperKeyword */,
|
|
switch: 107 /* SwitchKeyword */,
|
|
symbol: 153 /* SymbolKeyword */,
|
|
this: 108 /* ThisKeyword */,
|
|
throw: 109 /* ThrowKeyword */,
|
|
true: 110 /* TrueKeyword */,
|
|
try: 111 /* TryKeyword */,
|
|
type: 154 /* TypeKeyword */,
|
|
typeof: 112 /* TypeOfKeyword */,
|
|
undefined: 155 /* UndefinedKeyword */,
|
|
unique: 156 /* UniqueKeyword */,
|
|
unknown: 157 /* UnknownKeyword */,
|
|
var: 113 /* VarKeyword */,
|
|
void: 114 /* VoidKeyword */,
|
|
while: 115 /* WhileKeyword */,
|
|
with: 116 /* WithKeyword */,
|
|
yield: 125 /* YieldKeyword */,
|
|
async: 132 /* AsyncKeyword */,
|
|
await: 133 /* AwaitKeyword */,
|
|
of: 162 /* OfKeyword */
|
|
};
|
|
var textToKeyword = new Map(getEntries(textToKeywordObj));
|
|
var textToToken = new Map(getEntries({
|
|
...textToKeywordObj,
|
|
"{": 18 /* OpenBraceToken */,
|
|
"}": 19 /* CloseBraceToken */,
|
|
"(": 20 /* OpenParenToken */,
|
|
")": 21 /* CloseParenToken */,
|
|
"[": 22 /* OpenBracketToken */,
|
|
"]": 23 /* CloseBracketToken */,
|
|
".": 24 /* DotToken */,
|
|
"...": 25 /* DotDotDotToken */,
|
|
";": 26 /* SemicolonToken */,
|
|
",": 27 /* CommaToken */,
|
|
"<": 29 /* LessThanToken */,
|
|
">": 31 /* GreaterThanToken */,
|
|
"<=": 32 /* LessThanEqualsToken */,
|
|
">=": 33 /* GreaterThanEqualsToken */,
|
|
"==": 34 /* EqualsEqualsToken */,
|
|
"!=": 35 /* ExclamationEqualsToken */,
|
|
"===": 36 /* EqualsEqualsEqualsToken */,
|
|
"!==": 37 /* ExclamationEqualsEqualsToken */,
|
|
"=>": 38 /* EqualsGreaterThanToken */,
|
|
"+": 39 /* PlusToken */,
|
|
"-": 40 /* MinusToken */,
|
|
"**": 42 /* AsteriskAsteriskToken */,
|
|
"*": 41 /* AsteriskToken */,
|
|
"/": 43 /* SlashToken */,
|
|
"%": 44 /* PercentToken */,
|
|
"++": 45 /* PlusPlusToken */,
|
|
"--": 46 /* MinusMinusToken */,
|
|
"<<": 47 /* LessThanLessThanToken */,
|
|
"</": 30 /* LessThanSlashToken */,
|
|
">>": 48 /* GreaterThanGreaterThanToken */,
|
|
">>>": 49 /* GreaterThanGreaterThanGreaterThanToken */,
|
|
"&": 50 /* AmpersandToken */,
|
|
"|": 51 /* BarToken */,
|
|
"^": 52 /* CaretToken */,
|
|
"!": 53 /* ExclamationToken */,
|
|
"~": 54 /* TildeToken */,
|
|
"&&": 55 /* AmpersandAmpersandToken */,
|
|
"||": 56 /* BarBarToken */,
|
|
"?": 57 /* QuestionToken */,
|
|
"??": 60 /* QuestionQuestionToken */,
|
|
"?.": 28 /* QuestionDotToken */,
|
|
":": 58 /* ColonToken */,
|
|
"=": 63 /* EqualsToken */,
|
|
"+=": 64 /* PlusEqualsToken */,
|
|
"-=": 65 /* MinusEqualsToken */,
|
|
"*=": 66 /* AsteriskEqualsToken */,
|
|
"**=": 67 /* AsteriskAsteriskEqualsToken */,
|
|
"/=": 68 /* SlashEqualsToken */,
|
|
"%=": 69 /* PercentEqualsToken */,
|
|
"<<=": 70 /* LessThanLessThanEqualsToken */,
|
|
">>=": 71 /* GreaterThanGreaterThanEqualsToken */,
|
|
">>>=": 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */,
|
|
"&=": 73 /* AmpersandEqualsToken */,
|
|
"|=": 74 /* BarEqualsToken */,
|
|
"^=": 78 /* CaretEqualsToken */,
|
|
"||=": 75 /* BarBarEqualsToken */,
|
|
"&&=": 76 /* AmpersandAmpersandEqualsToken */,
|
|
"??=": 77 /* QuestionQuestionEqualsToken */,
|
|
"@": 59 /* AtToken */,
|
|
"#": 62 /* HashToken */,
|
|
"`": 61 /* BacktickToken */
|
|
}));
|
|
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];
|
|
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, 6e3, 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, 43e3, 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, 6e3, 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, 43e3, 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];
|
|
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, 6e3, 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, 6e3, 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];
|
|
var commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/;
|
|
var commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/;
|
|
function lookupInUnicodeMap(code, map2) {
|
|
if (code < map2[0]) {
|
|
return false;
|
|
}
|
|
let lo = 0;
|
|
let hi = map2.length;
|
|
let mid;
|
|
while (lo + 1 < hi) {
|
|
mid = lo + (hi - lo) / 2;
|
|
mid -= mid % 2;
|
|
if (map2[mid] <= code && code <= map2[mid + 1]) {
|
|
return true;
|
|
}
|
|
if (code < map2[mid]) {
|
|
hi = mid;
|
|
} else {
|
|
lo = mid + 2;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isUnicodeIdentifierStart(code, languageVersion) {
|
|
return languageVersion >= 2 /* ES2015 */ ? lookupInUnicodeMap(code, unicodeESNextIdentifierStart) : languageVersion === 1 /* ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : lookupInUnicodeMap(code, unicodeES3IdentifierStart);
|
|
}
|
|
function isUnicodeIdentifierPart(code, languageVersion) {
|
|
return languageVersion >= 2 /* ES2015 */ ? lookupInUnicodeMap(code, unicodeESNextIdentifierPart) : languageVersion === 1 /* ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : lookupInUnicodeMap(code, unicodeES3IdentifierPart);
|
|
}
|
|
function makeReverseMap(source) {
|
|
const result = [];
|
|
source.forEach((value, name) => {
|
|
result[value] = name;
|
|
});
|
|
return result;
|
|
}
|
|
var tokenStrings = makeReverseMap(textToToken);
|
|
function tokenToString(t) {
|
|
return tokenStrings[t];
|
|
}
|
|
function stringToToken(s) {
|
|
return textToToken.get(s);
|
|
}
|
|
function computeLineStarts(text) {
|
|
const result = [];
|
|
let pos = 0;
|
|
let lineStart = 0;
|
|
while (pos < text.length) {
|
|
const ch = text.charCodeAt(pos);
|
|
pos++;
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
result.push(lineStart);
|
|
lineStart = pos;
|
|
break;
|
|
default:
|
|
if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
|
|
result.push(lineStart);
|
|
lineStart = pos;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
result.push(lineStart);
|
|
return result;
|
|
}
|
|
function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) {
|
|
return sourceFile.getPositionOfLineAndCharacter ? sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) : computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits);
|
|
}
|
|
function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) {
|
|
if (line < 0 || line >= lineStarts.length) {
|
|
if (allowEdits) {
|
|
line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line;
|
|
} else {
|
|
Debug.fail(`Bad line number. Line: ${line}, lineStarts.length: ${lineStarts.length} , line map is correct? ${debugText !== void 0 ? arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown"}`);
|
|
}
|
|
}
|
|
const res = lineStarts[line] + character;
|
|
if (allowEdits) {
|
|
return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res;
|
|
}
|
|
if (line < lineStarts.length - 1) {
|
|
Debug.assert(res < lineStarts[line + 1]);
|
|
} else if (debugText !== void 0) {
|
|
Debug.assert(res <= debugText.length);
|
|
}
|
|
return res;
|
|
}
|
|
function getLineStarts(sourceFile) {
|
|
return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text));
|
|
}
|
|
function computeLineAndCharacterOfPosition(lineStarts, position) {
|
|
const lineNumber = computeLineOfPosition(lineStarts, position);
|
|
return {
|
|
line: lineNumber,
|
|
character: position - lineStarts[lineNumber]
|
|
};
|
|
}
|
|
function computeLineOfPosition(lineStarts, position, lowerBound) {
|
|
let lineNumber = binarySearch(lineStarts, position, identity, compareValues, lowerBound);
|
|
if (lineNumber < 0) {
|
|
lineNumber = ~lineNumber - 1;
|
|
Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file");
|
|
}
|
|
return lineNumber;
|
|
}
|
|
function getLinesBetweenPositions(sourceFile, pos1, pos2) {
|
|
if (pos1 === pos2)
|
|
return 0;
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
const lower = Math.min(pos1, pos2);
|
|
const isNegative = lower === pos2;
|
|
const upper = isNegative ? pos1 : pos2;
|
|
const lowerLine = computeLineOfPosition(lineStarts, lower);
|
|
const upperLine = computeLineOfPosition(lineStarts, upper, lowerLine);
|
|
return isNegative ? lowerLine - upperLine : upperLine - lowerLine;
|
|
}
|
|
function getLineAndCharacterOfPosition(sourceFile, position) {
|
|
return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
|
|
}
|
|
function isWhiteSpaceLike(ch) {
|
|
return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
|
|
}
|
|
function isWhiteSpaceSingleLine(ch) {
|
|
return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ || ch === 160 /* nonBreakingSpace */ || ch === 133 /* nextLine */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ || ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
|
|
}
|
|
function isLineBreak(ch) {
|
|
return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
|
|
}
|
|
function isDigit(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
|
|
}
|
|
function isHexDigit(ch) {
|
|
return isDigit(ch) || ch >= 65 /* A */ && ch <= 70 /* F */ || ch >= 97 /* a */ && ch <= 102 /* f */;
|
|
}
|
|
function isCodePoint(code) {
|
|
return code <= 1114111;
|
|
}
|
|
function isOctalDigit(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 55 /* _7 */;
|
|
}
|
|
function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) {
|
|
if (positionIsSynthesized(pos)) {
|
|
return pos;
|
|
}
|
|
let canConsumeStar = false;
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
pos++;
|
|
if (stopAfterLineBreak) {
|
|
return pos;
|
|
}
|
|
canConsumeStar = !!inJSDoc;
|
|
continue;
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
pos++;
|
|
continue;
|
|
case 47 /* slash */:
|
|
if (stopAtComments) {
|
|
break;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
while (pos < text.length) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
pos += 2;
|
|
while (pos < text.length) {
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 60 /* lessThan */:
|
|
case 124 /* bar */:
|
|
case 61 /* equals */:
|
|
case 62 /* greaterThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos);
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 35 /* hash */:
|
|
if (pos === 0 && isShebangTrivia(text, pos)) {
|
|
pos = scanShebangTrivia(text, pos);
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 42 /* asterisk */:
|
|
if (canConsumeStar) {
|
|
pos++;
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
default:
|
|
if (ch > 127 /* maxAsciiCharacter */ && isWhiteSpaceLike(ch)) {
|
|
pos++;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return pos;
|
|
}
|
|
}
|
|
var mergeConflictMarkerLength = "<<<<<<<".length;
|
|
function isConflictMarkerTrivia(text, pos) {
|
|
Debug.assert(pos >= 0);
|
|
if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (pos + mergeConflictMarkerLength < text.length) {
|
|
for (let i = 0; i < mergeConflictMarkerLength; i++) {
|
|
if (text.charCodeAt(pos + i) !== ch) {
|
|
return false;
|
|
}
|
|
}
|
|
return ch === 61 /* equals */ || text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* space */;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function scanConflictMarkerTrivia(text, pos, error) {
|
|
if (error) {
|
|
error(Diagnostics.Merge_conflict_marker_encountered, pos, mergeConflictMarkerLength);
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
const len = text.length;
|
|
if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) {
|
|
while (pos < len && !isLineBreak(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
} else {
|
|
Debug.assert(ch === 124 /* bar */ || ch === 61 /* equals */);
|
|
while (pos < len) {
|
|
const currentChar = text.charCodeAt(pos);
|
|
if ((currentChar === 61 /* equals */ || currentChar === 62 /* greaterThan */) && currentChar !== ch && isConflictMarkerTrivia(text, pos)) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
var shebangTriviaRegex = /^#!.*/;
|
|
function isShebangTrivia(text, pos) {
|
|
Debug.assert(pos === 0);
|
|
return shebangTriviaRegex.test(text);
|
|
}
|
|
function scanShebangTrivia(text, pos) {
|
|
const shebang = shebangTriviaRegex.exec(text)[0];
|
|
pos = pos + shebang.length;
|
|
return pos;
|
|
}
|
|
function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) {
|
|
let pendingPos;
|
|
let pendingEnd;
|
|
let pendingKind;
|
|
let pendingHasTrailingNewLine;
|
|
let hasPendingCommentRange = false;
|
|
let collecting = trailing;
|
|
let accumulator = initial;
|
|
if (pos === 0) {
|
|
collecting = true;
|
|
const shebang = getShebang(text);
|
|
if (shebang) {
|
|
pos = shebang.length;
|
|
}
|
|
}
|
|
scan:
|
|
while (pos >= 0 && pos < text.length) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
pos++;
|
|
if (trailing) {
|
|
break scan;
|
|
}
|
|
collecting = true;
|
|
if (hasPendingCommentRange) {
|
|
pendingHasTrailingNewLine = true;
|
|
}
|
|
continue;
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
pos++;
|
|
continue;
|
|
case 47 /* slash */:
|
|
const nextChar = text.charCodeAt(pos + 1);
|
|
let hasTrailingNewLine = false;
|
|
if (nextChar === 47 /* slash */ || nextChar === 42 /* asterisk */) {
|
|
const kind = nextChar === 47 /* slash */ ? 2 /* SingleLineCommentTrivia */ : 3 /* MultiLineCommentTrivia */;
|
|
const startPos = pos;
|
|
pos += 2;
|
|
if (nextChar === 47 /* slash */) {
|
|
while (pos < text.length) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
hasTrailingNewLine = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
} else {
|
|
while (pos < text.length) {
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
}
|
|
if (collecting) {
|
|
if (hasPendingCommentRange) {
|
|
accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
|
|
if (!reduce && accumulator) {
|
|
return accumulator;
|
|
}
|
|
}
|
|
pendingPos = startPos;
|
|
pendingEnd = pos;
|
|
pendingKind = kind;
|
|
pendingHasTrailingNewLine = hasTrailingNewLine;
|
|
hasPendingCommentRange = true;
|
|
}
|
|
continue;
|
|
}
|
|
break scan;
|
|
default:
|
|
if (ch > 127 /* 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(false, text, pos, false, cb, state);
|
|
}
|
|
function forEachTrailingCommentRange(text, pos, cb, state) {
|
|
return iterateCommentRanges(false, text, pos, true, cb, state);
|
|
}
|
|
function reduceEachLeadingCommentRange(text, pos, cb, state, initial) {
|
|
return iterateCommentRanges(true, text, pos, false, cb, state, initial);
|
|
}
|
|
function reduceEachTrailingCommentRange(text, pos, cb, state, initial) {
|
|
return iterateCommentRanges(true, text, pos, true, cb, state, initial);
|
|
}
|
|
function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) {
|
|
if (!comments) {
|
|
comments = [];
|
|
}
|
|
comments.push({ kind, pos, end, hasTrailingNewLine });
|
|
return comments;
|
|
}
|
|
function getLeadingCommentRanges(text, pos) {
|
|
return reduceEachLeadingCommentRange(text, pos, appendCommentRange, void 0, void 0);
|
|
}
|
|
function getTrailingCommentRanges(text, pos) {
|
|
return reduceEachTrailingCommentRange(text, pos, appendCommentRange, void 0, void 0);
|
|
}
|
|
function getShebang(text) {
|
|
const match = shebangTriviaRegex.exec(text);
|
|
if (match) {
|
|
return match[0];
|
|
}
|
|
}
|
|
function isIdentifierStart(ch, languageVersion) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
|
|
}
|
|
function isIdentifierPart(ch, languageVersion, identifierVariant) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
|
|
}
|
|
function isIdentifierText(name, languageVersion, identifierVariant) {
|
|
let ch = codePointAt(name, 0);
|
|
if (!isIdentifierStart(ch, languageVersion)) {
|
|
return false;
|
|
}
|
|
for (let i = charSize(ch); i < name.length; i += charSize(ch)) {
|
|
if (!isIdentifierPart(ch = codePointAt(name, i), languageVersion, identifierVariant)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Standard */, textInitial, onError, start, length2) {
|
|
let text = textInitial;
|
|
let pos;
|
|
let end;
|
|
let startPos;
|
|
let tokenPos;
|
|
let token;
|
|
let tokenValue;
|
|
let tokenFlags;
|
|
let commentDirectives;
|
|
let inJSDocType = 0;
|
|
setText(text, start, length2);
|
|
const scanner = {
|
|
getStartPos: () => startPos,
|
|
getTextPos: () => pos,
|
|
getToken: () => token,
|
|
getTokenPos: () => tokenPos,
|
|
getTokenText: () => text.substring(tokenPos, pos),
|
|
getTokenValue: () => tokenValue,
|
|
hasUnicodeEscape: () => (tokenFlags & 1024 /* UnicodeEscape */) !== 0,
|
|
hasExtendedUnicodeEscape: () => (tokenFlags & 8 /* ExtendedUnicodeEscape */) !== 0,
|
|
hasPrecedingLineBreak: () => (tokenFlags & 1 /* PrecedingLineBreak */) !== 0,
|
|
hasPrecedingJSDocComment: () => (tokenFlags & 2 /* PrecedingJSDocComment */) !== 0,
|
|
isIdentifier: () => token === 79 /* Identifier */ || token > 116 /* LastReservedWord */,
|
|
isReservedWord: () => token >= 81 /* FirstReservedWord */ && token <= 116 /* LastReservedWord */,
|
|
isUnterminated: () => (tokenFlags & 4 /* Unterminated */) !== 0,
|
|
getCommentDirectives: () => commentDirectives,
|
|
getNumericLiteralFlags: () => tokenFlags & 1008 /* NumericLiteralFlags */,
|
|
getTokenFlags: () => tokenFlags,
|
|
reScanGreaterToken,
|
|
reScanAsteriskEqualsToken,
|
|
reScanSlashToken,
|
|
reScanTemplateToken,
|
|
reScanTemplateHeadOrNoSubstitutionTemplate,
|
|
scanJsxIdentifier,
|
|
scanJsxAttributeValue,
|
|
reScanJsxAttributeValue,
|
|
reScanJsxToken,
|
|
reScanLessThanToken,
|
|
reScanHashToken,
|
|
reScanQuestionToken,
|
|
reScanInvalidIdentifier,
|
|
scanJsxToken,
|
|
scanJsDocToken,
|
|
scan,
|
|
getText,
|
|
clearCommentDirectives,
|
|
setText,
|
|
setScriptTarget,
|
|
setLanguageVariant,
|
|
setOnError,
|
|
setTextPos,
|
|
setInJSDocType,
|
|
tryScan,
|
|
lookAhead,
|
|
scanRange
|
|
};
|
|
if (Debug.isDebugging) {
|
|
Object.defineProperty(scanner, "__debugShowCurrentPositionInText", {
|
|
get: () => {
|
|
const text2 = scanner.getText();
|
|
return text2.slice(0, scanner.getStartPos()) + "\u2551" + text2.slice(scanner.getStartPos());
|
|
}
|
|
});
|
|
}
|
|
return scanner;
|
|
function error(message, errPos = pos, length3) {
|
|
if (onError) {
|
|
const oldPos = pos;
|
|
pos = errPos;
|
|
onError(message, length3 || 0);
|
|
pos = oldPos;
|
|
}
|
|
}
|
|
function scanNumberFragment() {
|
|
let start2 = pos;
|
|
let allowSeparator = false;
|
|
let isPreviousTokenSeparator = false;
|
|
let result = "";
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (allowSeparator) {
|
|
allowSeparator = false;
|
|
isPreviousTokenSeparator = true;
|
|
result += text.substring(start2, pos);
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
start2 = pos;
|
|
continue;
|
|
}
|
|
if (isDigit(ch)) {
|
|
allowSeparator = true;
|
|
isPreviousTokenSeparator = false;
|
|
pos++;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return result + text.substring(start2, pos);
|
|
}
|
|
function scanNumber() {
|
|
const start2 = pos;
|
|
const mainFragment = scanNumberFragment();
|
|
let decimalFragment;
|
|
let scientificFragment;
|
|
if (text.charCodeAt(pos) === 46 /* dot */) {
|
|
pos++;
|
|
decimalFragment = scanNumberFragment();
|
|
}
|
|
let end2 = pos;
|
|
if (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */) {
|
|
pos++;
|
|
tokenFlags |= 16 /* Scientific */;
|
|
if (text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */)
|
|
pos++;
|
|
const preNumericPart = pos;
|
|
const finalFragment = scanNumberFragment();
|
|
if (!finalFragment) {
|
|
error(Diagnostics.Digit_expected);
|
|
} else {
|
|
scientificFragment = text.substring(end2, preNumericPart) + finalFragment;
|
|
end2 = pos;
|
|
}
|
|
}
|
|
let result;
|
|
if (tokenFlags & 512 /* ContainsSeparator */) {
|
|
result = mainFragment;
|
|
if (decimalFragment) {
|
|
result += "." + decimalFragment;
|
|
}
|
|
if (scientificFragment) {
|
|
result += scientificFragment;
|
|
}
|
|
} else {
|
|
result = text.substring(start2, end2);
|
|
}
|
|
if (decimalFragment !== void 0 || tokenFlags & 16 /* Scientific */) {
|
|
checkForIdentifierStartAfterNumericLiteral(start2, decimalFragment === void 0 && !!(tokenFlags & 16 /* Scientific */));
|
|
return {
|
|
type: 8 /* NumericLiteral */,
|
|
value: "" + +result
|
|
};
|
|
} else {
|
|
tokenValue = result;
|
|
const type = checkBigIntSuffix();
|
|
checkForIdentifierStartAfterNumericLiteral(start2);
|
|
return { type, value: tokenValue };
|
|
}
|
|
}
|
|
function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) {
|
|
if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) {
|
|
return;
|
|
}
|
|
const identifierStart = pos;
|
|
const { length: length3 } = scanIdentifierParts();
|
|
if (length3 === 1 && text[identifierStart] === "n") {
|
|
if (isScientific) {
|
|
error(Diagnostics.A_bigint_literal_cannot_use_exponential_notation, numericStart, identifierStart - numericStart + 1);
|
|
} else {
|
|
error(Diagnostics.A_bigint_literal_must_be_an_integer, numericStart, identifierStart - numericStart + 1);
|
|
}
|
|
} else {
|
|
error(Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, identifierStart, length3);
|
|
pos = identifierStart;
|
|
}
|
|
}
|
|
function scanOctalDigits() {
|
|
const start2 = pos;
|
|
while (isOctalDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return +text.substring(start2, pos);
|
|
}
|
|
function scanExactNumberOfHexDigits(count, canHaveSeparators) {
|
|
const valueString = scanHexDigits(count, false, canHaveSeparators);
|
|
return valueString ? parseInt(valueString, 16) : -1;
|
|
}
|
|
function scanMinimumNumberOfHexDigits(count, canHaveSeparators) {
|
|
return scanHexDigits(count, true, canHaveSeparators);
|
|
}
|
|
function scanHexDigits(minCount, scanAsManyAsPossible, canHaveSeparators) {
|
|
let valueChars = [];
|
|
let allowSeparator = false;
|
|
let isPreviousTokenSeparator = false;
|
|
while (valueChars.length < minCount || scanAsManyAsPossible) {
|
|
let ch = text.charCodeAt(pos);
|
|
if (canHaveSeparators && ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (allowSeparator) {
|
|
allowSeparator = false;
|
|
isPreviousTokenSeparator = true;
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
continue;
|
|
}
|
|
allowSeparator = canHaveSeparators;
|
|
if (ch >= 65 /* A */ && ch <= 70 /* F */) {
|
|
ch += 97 /* a */ - 65 /* A */;
|
|
} else if (!(ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch >= 97 /* a */ && ch <= 102 /* f */)) {
|
|
break;
|
|
}
|
|
valueChars.push(ch);
|
|
pos++;
|
|
isPreviousTokenSeparator = false;
|
|
}
|
|
if (valueChars.length < minCount) {
|
|
valueChars = [];
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return String.fromCharCode(...valueChars);
|
|
}
|
|
function scanString(jsxAttributeString = false) {
|
|
const quote = text.charCodeAt(pos);
|
|
pos++;
|
|
let result = "";
|
|
let start2 = pos;
|
|
while (true) {
|
|
if (pos >= end) {
|
|
result += text.substring(start2, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_string_literal);
|
|
break;
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === quote) {
|
|
result += text.substring(start2, pos);
|
|
pos++;
|
|
break;
|
|
}
|
|
if (ch === 92 /* backslash */ && !jsxAttributeString) {
|
|
result += text.substring(start2, pos);
|
|
result += scanEscapeSequence();
|
|
start2 = pos;
|
|
continue;
|
|
}
|
|
if (isLineBreak(ch) && !jsxAttributeString) {
|
|
result += text.substring(start2, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_string_literal);
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
return result;
|
|
}
|
|
function scanTemplateAndSetTokenValue(isTaggedTemplate) {
|
|
const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
|
|
pos++;
|
|
let start2 = pos;
|
|
let contents = "";
|
|
let resultingToken;
|
|
while (true) {
|
|
if (pos >= end) {
|
|
contents += text.substring(start2, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_template_literal);
|
|
resultingToken = startedWithBacktick ? 14 /* NoSubstitutionTemplateLiteral */ : 17 /* TemplateTail */;
|
|
break;
|
|
}
|
|
const currChar = text.charCodeAt(pos);
|
|
if (currChar === 96 /* backtick */) {
|
|
contents += text.substring(start2, pos);
|
|
pos++;
|
|
resultingToken = startedWithBacktick ? 14 /* NoSubstitutionTemplateLiteral */ : 17 /* TemplateTail */;
|
|
break;
|
|
}
|
|
if (currChar === 36 /* $ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* openBrace */) {
|
|
contents += text.substring(start2, pos);
|
|
pos += 2;
|
|
resultingToken = startedWithBacktick ? 15 /* TemplateHead */ : 16 /* TemplateMiddle */;
|
|
break;
|
|
}
|
|
if (currChar === 92 /* backslash */) {
|
|
contents += text.substring(start2, pos);
|
|
contents += scanEscapeSequence(isTaggedTemplate);
|
|
start2 = pos;
|
|
continue;
|
|
}
|
|
if (currChar === 13 /* carriageReturn */) {
|
|
contents += text.substring(start2, pos);
|
|
pos++;
|
|
if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
contents += "\n";
|
|
start2 = pos;
|
|
continue;
|
|
}
|
|
pos++;
|
|
}
|
|
Debug.assert(resultingToken !== void 0);
|
|
tokenValue = contents;
|
|
return resultingToken;
|
|
}
|
|
function scanEscapeSequence(isTaggedTemplate) {
|
|
const start2 = pos;
|
|
pos++;
|
|
if (pos >= end) {
|
|
error(Diagnostics.Unexpected_end_of_text);
|
|
return "";
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
pos++;
|
|
switch (ch) {
|
|
case 48 /* _0 */:
|
|
if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
}
|
|
return "\0";
|
|
case 98 /* b */:
|
|
return "\b";
|
|
case 116 /* t */:
|
|
return " ";
|
|
case 110 /* n */:
|
|
return "\n";
|
|
case 118 /* v */:
|
|
return "\v";
|
|
case 102 /* f */:
|
|
return "\f";
|
|
case 114 /* r */:
|
|
return "\r";
|
|
case 39 /* singleQuote */:
|
|
return "'";
|
|
case 34 /* doubleQuote */:
|
|
return '"';
|
|
case 117 /* u */:
|
|
if (isTaggedTemplate) {
|
|
for (let escapePos = pos; escapePos < pos + 4; escapePos++) {
|
|
if (escapePos < end && !isHexDigit(text.charCodeAt(escapePos)) && text.charCodeAt(escapePos) !== 123 /* openBrace */) {
|
|
pos = escapePos;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
}
|
|
}
|
|
}
|
|
if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
|
|
pos++;
|
|
if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
}
|
|
if (isTaggedTemplate) {
|
|
const savePos = pos;
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== 125 /* closeBrace */) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
} else {
|
|
pos = savePos;
|
|
}
|
|
}
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
return scanExtendedUnicodeEscape();
|
|
}
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
return scanHexadecimalEscape(4);
|
|
case 120 /* x */:
|
|
if (isTaggedTemplate) {
|
|
if (!isHexDigit(text.charCodeAt(pos))) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
} else if (!isHexDigit(text.charCodeAt(pos + 1))) {
|
|
pos++;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start2, pos);
|
|
}
|
|
}
|
|
return scanHexadecimalEscape(2);
|
|
case 13 /* carriageReturn */:
|
|
if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
case 8232 /* lineSeparator */:
|
|
case 8233 /* paragraphSeparator */:
|
|
return "";
|
|
default:
|
|
return String.fromCharCode(ch);
|
|
}
|
|
}
|
|
function scanHexadecimalEscape(numDigits) {
|
|
const escapedValue = scanExactNumberOfHexDigits(numDigits, false);
|
|
if (escapedValue >= 0) {
|
|
return String.fromCharCode(escapedValue);
|
|
} else {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
return "";
|
|
}
|
|
}
|
|
function scanExtendedUnicodeEscape() {
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
let isInvalidExtendedEscape = false;
|
|
if (escapedValue < 0) {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
isInvalidExtendedEscape = true;
|
|
} else if (escapedValue > 1114111) {
|
|
error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
|
|
isInvalidExtendedEscape = true;
|
|
}
|
|
if (pos >= end) {
|
|
error(Diagnostics.Unexpected_end_of_text);
|
|
isInvalidExtendedEscape = true;
|
|
} else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
|
|
pos++;
|
|
} else {
|
|
error(Diagnostics.Unterminated_Unicode_escape_sequence);
|
|
isInvalidExtendedEscape = true;
|
|
}
|
|
if (isInvalidExtendedEscape) {
|
|
return "";
|
|
}
|
|
return utf16EncodeAsString(escapedValue);
|
|
}
|
|
function peekUnicodeEscape() {
|
|
if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* u */) {
|
|
const start2 = pos;
|
|
pos += 2;
|
|
const value = scanExactNumberOfHexDigits(4, false);
|
|
pos = start2;
|
|
return value;
|
|
}
|
|
return -1;
|
|
}
|
|
function peekExtendedUnicodeEscape() {
|
|
if (codePointAt(text, pos + 1) === 117 /* u */ && codePointAt(text, pos + 2) === 123 /* openBrace */) {
|
|
const start2 = pos;
|
|
pos += 3;
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
pos = start2;
|
|
return escapedValue;
|
|
}
|
|
return -1;
|
|
}
|
|
function scanIdentifierParts() {
|
|
let result = "";
|
|
let start2 = pos;
|
|
while (pos < end) {
|
|
let ch = codePointAt(text, pos);
|
|
if (isIdentifierPart(ch, languageVersion)) {
|
|
pos += charSize(ch);
|
|
} else if (ch === 92 /* backslash */) {
|
|
ch = peekExtendedUnicodeEscape();
|
|
if (ch >= 0 && isIdentifierPart(ch, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
result += scanExtendedUnicodeEscape();
|
|
start2 = pos;
|
|
continue;
|
|
}
|
|
ch = peekUnicodeEscape();
|
|
if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) {
|
|
break;
|
|
}
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
result += text.substring(start2, pos);
|
|
result += utf16EncodeAsString(ch);
|
|
pos += 6;
|
|
start2 = pos;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
result += text.substring(start2, pos);
|
|
return result;
|
|
}
|
|
function getIdentifierToken() {
|
|
const len = tokenValue.length;
|
|
if (len >= 2 && len <= 12) {
|
|
const ch = tokenValue.charCodeAt(0);
|
|
if (ch >= 97 /* a */ && ch <= 122 /* z */) {
|
|
const keyword = textToKeyword.get(tokenValue);
|
|
if (keyword !== void 0) {
|
|
return token = keyword;
|
|
}
|
|
}
|
|
}
|
|
return token = 79 /* Identifier */;
|
|
}
|
|
function scanBinaryOrOctalDigits(base) {
|
|
let value = "";
|
|
let separatorAllowed = false;
|
|
let isPreviousTokenSeparator = false;
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (separatorAllowed) {
|
|
separatorAllowed = false;
|
|
isPreviousTokenSeparator = true;
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
continue;
|
|
}
|
|
separatorAllowed = true;
|
|
if (!isDigit(ch) || ch - 48 /* _0 */ >= base) {
|
|
break;
|
|
}
|
|
value += text[pos];
|
|
pos++;
|
|
isPreviousTokenSeparator = false;
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return value;
|
|
}
|
|
function checkBigIntSuffix() {
|
|
if (text.charCodeAt(pos) === 110 /* n */) {
|
|
tokenValue += "n";
|
|
if (tokenFlags & 384 /* BinaryOrOctalSpecifier */) {
|
|
tokenValue = parsePseudoBigInt(tokenValue) + "n";
|
|
}
|
|
pos++;
|
|
return 9 /* BigIntLiteral */;
|
|
} else {
|
|
const numericValue = tokenFlags & 128 /* BinarySpecifier */ ? parseInt(tokenValue.slice(2), 2) : tokenFlags & 256 /* OctalSpecifier */ ? parseInt(tokenValue.slice(2), 8) : +tokenValue;
|
|
tokenValue = "" + numericValue;
|
|
return 8 /* NumericLiteral */;
|
|
}
|
|
}
|
|
function scan() {
|
|
startPos = pos;
|
|
tokenFlags = 0 /* None */;
|
|
let asteriskSeen = false;
|
|
while (true) {
|
|
tokenPos = pos;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
const ch = codePointAt(text, pos);
|
|
if (ch === 35 /* hash */ && pos === 0 && isShebangTrivia(text, pos)) {
|
|
pos = scanShebangTrivia(text, pos);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 6 /* ShebangTrivia */;
|
|
}
|
|
}
|
|
switch (ch) {
|
|
case 10 /* lineFeed */:
|
|
case 13 /* carriageReturn */:
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
if (skipTrivia2) {
|
|
pos++;
|
|
continue;
|
|
} else {
|
|
if (ch === 13 /* carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos += 2;
|
|
} else {
|
|
pos++;
|
|
}
|
|
return token = 4 /* NewLineTrivia */;
|
|
}
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
case 160 /* nonBreakingSpace */:
|
|
case 5760 /* ogham */:
|
|
case 8192 /* enQuad */:
|
|
case 8193 /* emQuad */:
|
|
case 8194 /* enSpace */:
|
|
case 8195 /* emSpace */:
|
|
case 8196 /* threePerEmSpace */:
|
|
case 8197 /* fourPerEmSpace */:
|
|
case 8198 /* sixPerEmSpace */:
|
|
case 8199 /* figureSpace */:
|
|
case 8200 /* punctuationSpace */:
|
|
case 8201 /* thinSpace */:
|
|
case 8202 /* hairSpace */:
|
|
case 8203 /* zeroWidthSpace */:
|
|
case 8239 /* narrowNoBreakSpace */:
|
|
case 8287 /* mathematicalSpace */:
|
|
case 12288 /* ideographicSpace */:
|
|
case 65279 /* byteOrderMark */:
|
|
if (skipTrivia2) {
|
|
pos++;
|
|
continue;
|
|
} else {
|
|
while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return token = 5 /* WhitespaceTrivia */;
|
|
}
|
|
case 33 /* exclamation */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 37 /* ExclamationEqualsEqualsToken */;
|
|
}
|
|
return pos += 2, token = 35 /* ExclamationEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 53 /* ExclamationToken */;
|
|
case 34 /* doubleQuote */:
|
|
case 39 /* singleQuote */:
|
|
tokenValue = scanString();
|
|
return token = 10 /* StringLiteral */;
|
|
case 96 /* backtick */:
|
|
return token = scanTemplateAndSetTokenValue(false);
|
|
case 37 /* percent */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 69 /* PercentEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 44 /* PercentToken */;
|
|
case 38 /* ampersand */:
|
|
if (text.charCodeAt(pos + 1) === 38 /* ampersand */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 76 /* AmpersandAmpersandEqualsToken */;
|
|
}
|
|
return pos += 2, token = 55 /* AmpersandAmpersandToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 73 /* AmpersandEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 50 /* AmpersandToken */;
|
|
case 40 /* openParen */:
|
|
pos++;
|
|
return token = 20 /* OpenParenToken */;
|
|
case 41 /* closeParen */:
|
|
pos++;
|
|
return token = 21 /* CloseParenToken */;
|
|
case 42 /* asterisk */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 66 /* AsteriskEqualsToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 67 /* AsteriskAsteriskEqualsToken */;
|
|
}
|
|
return pos += 2, token = 42 /* AsteriskAsteriskToken */;
|
|
}
|
|
pos++;
|
|
if (inJSDocType && !asteriskSeen && tokenFlags & 1 /* PrecedingLineBreak */) {
|
|
asteriskSeen = true;
|
|
continue;
|
|
}
|
|
return token = 41 /* AsteriskToken */;
|
|
case 43 /* plus */:
|
|
if (text.charCodeAt(pos + 1) === 43 /* plus */) {
|
|
return pos += 2, token = 45 /* PlusPlusToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 64 /* PlusEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 39 /* PlusToken */;
|
|
case 44 /* comma */:
|
|
pos++;
|
|
return token = 27 /* CommaToken */;
|
|
case 45 /* minus */:
|
|
if (text.charCodeAt(pos + 1) === 45 /* minus */) {
|
|
return pos += 2, token = 46 /* MinusMinusToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 65 /* MinusEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 40 /* MinusToken */;
|
|
case 46 /* dot */:
|
|
if (isDigit(text.charCodeAt(pos + 1))) {
|
|
tokenValue = scanNumber().value;
|
|
return token = 8 /* NumericLiteral */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 46 /* dot */ && text.charCodeAt(pos + 2) === 46 /* dot */) {
|
|
return pos += 3, token = 25 /* DotDotDotToken */;
|
|
}
|
|
pos++;
|
|
return token = 24 /* DotToken */;
|
|
case 47 /* slash */:
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
while (pos < end) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
commentDirectives = appendIfCommentDirective(
|
|
commentDirectives,
|
|
text.slice(tokenPos, pos),
|
|
commentDirectiveRegExSingleLine,
|
|
tokenPos
|
|
);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 2 /* SingleLineCommentTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
pos += 2;
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) !== 47 /* slash */) {
|
|
tokenFlags |= 2 /* PrecedingJSDocComment */;
|
|
}
|
|
let commentClosed = false;
|
|
let lastLineStart = tokenPos;
|
|
while (pos < end) {
|
|
const ch2 = text.charCodeAt(pos);
|
|
if (ch2 === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
commentClosed = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
if (isLineBreak(ch2)) {
|
|
lastLineStart = pos;
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
}
|
|
}
|
|
commentDirectives = appendIfCommentDirective(commentDirectives, text.slice(lastLineStart, pos), commentDirectiveRegExMultiLine, lastLineStart);
|
|
if (!commentClosed) {
|
|
error(Diagnostics.Asterisk_Slash_expected);
|
|
}
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
if (!commentClosed) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
}
|
|
return token = 3 /* MultiLineCommentTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 68 /* SlashEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 43 /* SlashToken */;
|
|
case 48 /* _0 */:
|
|
if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* X */ || text.charCodeAt(pos + 1) === 120 /* x */)) {
|
|
pos += 2;
|
|
tokenValue = scanMinimumNumberOfHexDigits(1, true);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0x" + tokenValue;
|
|
tokenFlags |= 64 /* HexSpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
} else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* B */ || text.charCodeAt(pos + 1) === 98 /* b */)) {
|
|
pos += 2;
|
|
tokenValue = scanBinaryOrOctalDigits(2);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Binary_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0b" + tokenValue;
|
|
tokenFlags |= 128 /* BinarySpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
} else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* O */ || text.charCodeAt(pos + 1) === 111 /* o */)) {
|
|
pos += 2;
|
|
tokenValue = scanBinaryOrOctalDigits(8);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Octal_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0o" + tokenValue;
|
|
tokenFlags |= 256 /* OctalSpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
}
|
|
if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) {
|
|
tokenValue = "" + scanOctalDigits();
|
|
tokenFlags |= 32 /* Octal */;
|
|
return token = 8 /* NumericLiteral */;
|
|
}
|
|
case 49 /* _1 */:
|
|
case 50 /* _2 */:
|
|
case 51 /* _3 */:
|
|
case 52 /* _4 */:
|
|
case 53 /* _5 */:
|
|
case 54 /* _6 */:
|
|
case 55 /* _7 */:
|
|
case 56 /* _8 */:
|
|
case 57 /* _9 */:
|
|
({ type: token, value: tokenValue } = scanNumber());
|
|
return token;
|
|
case 58 /* colon */:
|
|
pos++;
|
|
return token = 58 /* ColonToken */;
|
|
case 59 /* semicolon */:
|
|
pos++;
|
|
return token = 26 /* SemicolonToken */;
|
|
case 60 /* lessThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 60 /* lessThan */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 70 /* LessThanLessThanEqualsToken */;
|
|
}
|
|
return pos += 2, token = 47 /* LessThanLessThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 32 /* LessThanEqualsToken */;
|
|
}
|
|
if (languageVariant === 1 /* JSX */ && text.charCodeAt(pos + 1) === 47 /* slash */ && text.charCodeAt(pos + 2) !== 42 /* asterisk */) {
|
|
return pos += 2, token = 30 /* LessThanSlashToken */;
|
|
}
|
|
pos++;
|
|
return token = 29 /* LessThanToken */;
|
|
case 61 /* equals */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 36 /* EqualsEqualsEqualsToken */;
|
|
}
|
|
return pos += 2, token = 34 /* EqualsEqualsToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
|
|
return pos += 2, token = 38 /* EqualsGreaterThanToken */;
|
|
}
|
|
pos++;
|
|
return token = 63 /* EqualsToken */;
|
|
case 62 /* greaterThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
pos++;
|
|
return token = 31 /* GreaterThanToken */;
|
|
case 63 /* question */:
|
|
if (text.charCodeAt(pos + 1) === 46 /* dot */ && !isDigit(text.charCodeAt(pos + 2))) {
|
|
return pos += 2, token = 28 /* QuestionDotToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 63 /* question */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 77 /* QuestionQuestionEqualsToken */;
|
|
}
|
|
return pos += 2, token = 60 /* QuestionQuestionToken */;
|
|
}
|
|
pos++;
|
|
return token = 57 /* QuestionToken */;
|
|
case 91 /* openBracket */:
|
|
pos++;
|
|
return token = 22 /* OpenBracketToken */;
|
|
case 93 /* closeBracket */:
|
|
pos++;
|
|
return token = 23 /* CloseBracketToken */;
|
|
case 94 /* caret */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 78 /* CaretEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 52 /* CaretToken */;
|
|
case 123 /* openBrace */:
|
|
pos++;
|
|
return token = 18 /* OpenBraceToken */;
|
|
case 124 /* bar */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 124 /* bar */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 75 /* BarBarEqualsToken */;
|
|
}
|
|
return pos += 2, token = 56 /* BarBarToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 74 /* BarEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 51 /* BarToken */;
|
|
case 125 /* closeBrace */:
|
|
pos++;
|
|
return token = 19 /* CloseBraceToken */;
|
|
case 126 /* tilde */:
|
|
pos++;
|
|
return token = 54 /* TildeToken */;
|
|
case 64 /* at */:
|
|
pos++;
|
|
return token = 59 /* AtToken */;
|
|
case 92 /* backslash */:
|
|
const extendedCookedChar = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
const cookedChar = peekUnicodeEscape();
|
|
if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
error(Diagnostics.Invalid_character);
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
case 35 /* hash */:
|
|
if (pos !== 0 && text[pos + 1] === "!") {
|
|
error(Diagnostics.can_only_be_used_at_the_start_of_a_file);
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
const charAfterHash = codePointAt(text, pos + 1);
|
|
if (charAfterHash === 92 /* backslash */) {
|
|
pos++;
|
|
const extendedCookedChar2 = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar2 >= 0 && isIdentifierStart(extendedCookedChar2, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = 80 /* PrivateIdentifier */;
|
|
}
|
|
const cookedChar2 = peekUnicodeEscape();
|
|
if (cookedChar2 >= 0 && isIdentifierStart(cookedChar2, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = "#" + String.fromCharCode(cookedChar2) + scanIdentifierParts();
|
|
return token = 80 /* PrivateIdentifier */;
|
|
}
|
|
pos--;
|
|
}
|
|
if (isIdentifierStart(charAfterHash, languageVersion)) {
|
|
pos++;
|
|
scanIdentifier(charAfterHash, languageVersion);
|
|
} else {
|
|
tokenValue = "#";
|
|
error(Diagnostics.Invalid_character, pos++, charSize(ch));
|
|
}
|
|
return token = 80 /* PrivateIdentifier */;
|
|
default:
|
|
const identifierKind = scanIdentifier(ch, languageVersion);
|
|
if (identifierKind) {
|
|
return token = identifierKind;
|
|
} else if (isWhiteSpaceSingleLine(ch)) {
|
|
pos += charSize(ch);
|
|
continue;
|
|
} else if (isLineBreak(ch)) {
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
pos += charSize(ch);
|
|
continue;
|
|
}
|
|
const size = charSize(ch);
|
|
error(Diagnostics.Invalid_character, pos, size);
|
|
pos += size;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
}
|
|
}
|
|
function reScanInvalidIdentifier() {
|
|
Debug.assert(token === 0 /* Unknown */, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'.");
|
|
pos = tokenPos = startPos;
|
|
tokenFlags = 0;
|
|
const ch = codePointAt(text, pos);
|
|
const identifierKind = scanIdentifier(ch, 99 /* ESNext */);
|
|
if (identifierKind) {
|
|
return token = identifierKind;
|
|
}
|
|
pos += charSize(ch);
|
|
return token;
|
|
}
|
|
function scanIdentifier(startCharacter, languageVersion2) {
|
|
let ch = startCharacter;
|
|
if (isIdentifierStart(ch, languageVersion2)) {
|
|
pos += charSize(ch);
|
|
while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion2))
|
|
pos += charSize(ch);
|
|
tokenValue = text.substring(tokenPos, pos);
|
|
if (ch === 92 /* backslash */) {
|
|
tokenValue += scanIdentifierParts();
|
|
}
|
|
return getIdentifierToken();
|
|
}
|
|
}
|
|
function reScanGreaterToken() {
|
|
if (token === 31 /* GreaterThanToken */) {
|
|
if (text.charCodeAt(pos) === 62 /* greaterThan */) {
|
|
if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
|
|
}
|
|
return pos += 2, token = 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 71 /* GreaterThanGreaterThanEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 48 /* GreaterThanGreaterThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos) === 61 /* equals */) {
|
|
pos++;
|
|
return token = 33 /* GreaterThanEqualsToken */;
|
|
}
|
|
}
|
|
return token;
|
|
}
|
|
function reScanAsteriskEqualsToken() {
|
|
Debug.assert(token === 66 /* AsteriskEqualsToken */, "'reScanAsteriskEqualsToken' should only be called on a '*='");
|
|
pos = tokenPos + 1;
|
|
return token = 63 /* EqualsToken */;
|
|
}
|
|
function reScanSlashToken() {
|
|
if (token === 43 /* SlashToken */ || token === 68 /* SlashEqualsToken */) {
|
|
let p = tokenPos + 1;
|
|
let inEscape = false;
|
|
let inCharacterClass = false;
|
|
while (true) {
|
|
if (p >= end) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_regular_expression_literal);
|
|
break;
|
|
}
|
|
const ch = text.charCodeAt(p);
|
|
if (isLineBreak(ch)) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_regular_expression_literal);
|
|
break;
|
|
}
|
|
if (inEscape) {
|
|
inEscape = false;
|
|
} else if (ch === 47 /* slash */ && !inCharacterClass) {
|
|
p++;
|
|
break;
|
|
} else if (ch === 91 /* openBracket */) {
|
|
inCharacterClass = true;
|
|
} else if (ch === 92 /* backslash */) {
|
|
inEscape = true;
|
|
} else if (ch === 93 /* closeBracket */) {
|
|
inCharacterClass = false;
|
|
}
|
|
p++;
|
|
}
|
|
while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) {
|
|
p++;
|
|
}
|
|
pos = p;
|
|
tokenValue = text.substring(tokenPos, pos);
|
|
token = 13 /* RegularExpressionLiteral */;
|
|
}
|
|
return token;
|
|
}
|
|
function appendIfCommentDirective(commentDirectives2, text2, commentDirectiveRegEx, lineStart) {
|
|
const type = getDirectiveFromComment(trimStringStart(text2), commentDirectiveRegEx);
|
|
if (type === void 0) {
|
|
return commentDirectives2;
|
|
}
|
|
return append(
|
|
commentDirectives2,
|
|
{
|
|
range: { pos: lineStart, end: pos },
|
|
type
|
|
}
|
|
);
|
|
}
|
|
function getDirectiveFromComment(text2, commentDirectiveRegEx) {
|
|
const match = commentDirectiveRegEx.exec(text2);
|
|
if (!match) {
|
|
return void 0;
|
|
}
|
|
switch (match[1]) {
|
|
case "ts-expect-error":
|
|
return 0 /* ExpectError */;
|
|
case "ts-ignore":
|
|
return 1 /* Ignore */;
|
|
}
|
|
return void 0;
|
|
}
|
|
function reScanTemplateToken(isTaggedTemplate) {
|
|
Debug.assert(token === 19 /* CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'");
|
|
pos = tokenPos;
|
|
return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
|
|
}
|
|
function reScanTemplateHeadOrNoSubstitutionTemplate() {
|
|
pos = tokenPos;
|
|
return token = scanTemplateAndSetTokenValue(true);
|
|
}
|
|
function reScanJsxToken(allowMultilineJsxText = true) {
|
|
pos = tokenPos = startPos;
|
|
return token = scanJsxToken(allowMultilineJsxText);
|
|
}
|
|
function reScanLessThanToken() {
|
|
if (token === 47 /* LessThanLessThanToken */) {
|
|
pos = tokenPos + 1;
|
|
return token = 29 /* LessThanToken */;
|
|
}
|
|
return token;
|
|
}
|
|
function reScanHashToken() {
|
|
if (token === 80 /* PrivateIdentifier */) {
|
|
pos = tokenPos + 1;
|
|
return token = 62 /* HashToken */;
|
|
}
|
|
return token;
|
|
}
|
|
function reScanQuestionToken() {
|
|
Debug.assert(token === 60 /* QuestionQuestionToken */, "'reScanQuestionToken' should only be called on a '??'");
|
|
pos = tokenPos + 1;
|
|
return token = 57 /* QuestionToken */;
|
|
}
|
|
function scanJsxToken(allowMultilineJsxText = true) {
|
|
startPos = tokenPos = pos;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
let char = text.charCodeAt(pos);
|
|
if (char === 60 /* lessThan */) {
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
return token = 30 /* LessThanSlashToken */;
|
|
}
|
|
pos++;
|
|
return token = 29 /* LessThanToken */;
|
|
}
|
|
if (char === 123 /* openBrace */) {
|
|
pos++;
|
|
return token = 18 /* OpenBraceToken */;
|
|
}
|
|
let firstNonWhitespace = 0;
|
|
while (pos < end) {
|
|
char = text.charCodeAt(pos);
|
|
if (char === 123 /* openBrace */) {
|
|
break;
|
|
}
|
|
if (char === 60 /* lessThan */) {
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
break;
|
|
}
|
|
if (char === 62 /* greaterThan */) {
|
|
error(Diagnostics.Unexpected_token_Did_you_mean_or_gt, pos, 1);
|
|
}
|
|
if (char === 125 /* closeBrace */) {
|
|
error(Diagnostics.Unexpected_token_Did_you_mean_or_rbrace, pos, 1);
|
|
}
|
|
if (isLineBreak(char) && firstNonWhitespace === 0) {
|
|
firstNonWhitespace = -1;
|
|
} else if (!allowMultilineJsxText && isLineBreak(char) && firstNonWhitespace > 0) {
|
|
break;
|
|
} else if (!isWhiteSpaceLike(char)) {
|
|
firstNonWhitespace = pos;
|
|
}
|
|
pos++;
|
|
}
|
|
tokenValue = text.substring(startPos, pos);
|
|
return firstNonWhitespace === -1 ? 12 /* JsxTextAllWhiteSpaces */ : 11 /* JsxText */;
|
|
}
|
|
function scanJsxIdentifier() {
|
|
if (tokenIsIdentifierOrKeyword(token)) {
|
|
let namespaceSeparator = false;
|
|
while (pos < end) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 45 /* minus */) {
|
|
tokenValue += "-";
|
|
pos++;
|
|
continue;
|
|
} else if (ch === 58 /* colon */ && !namespaceSeparator) {
|
|
tokenValue += ":";
|
|
pos++;
|
|
namespaceSeparator = true;
|
|
token = 79 /* Identifier */;
|
|
continue;
|
|
}
|
|
const oldPos = pos;
|
|
tokenValue += scanIdentifierParts();
|
|
if (pos === oldPos) {
|
|
break;
|
|
}
|
|
}
|
|
if (tokenValue.slice(-1) === ":") {
|
|
tokenValue = tokenValue.slice(0, -1);
|
|
pos--;
|
|
}
|
|
return getIdentifierToken();
|
|
}
|
|
return token;
|
|
}
|
|
function scanJsxAttributeValue() {
|
|
startPos = pos;
|
|
switch (text.charCodeAt(pos)) {
|
|
case 34 /* doubleQuote */:
|
|
case 39 /* singleQuote */:
|
|
tokenValue = scanString(true);
|
|
return token = 10 /* StringLiteral */;
|
|
default:
|
|
return scan();
|
|
}
|
|
}
|
|
function reScanJsxAttributeValue() {
|
|
pos = tokenPos = startPos;
|
|
return scanJsxAttributeValue();
|
|
}
|
|
function scanJsDocToken() {
|
|
startPos = tokenPos = pos;
|
|
tokenFlags = 0 /* None */;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
const ch = codePointAt(text, pos);
|
|
pos += charSize(ch);
|
|
switch (ch) {
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return token = 5 /* WhitespaceTrivia */;
|
|
case 64 /* at */:
|
|
return token = 59 /* AtToken */;
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
return token = 4 /* NewLineTrivia */;
|
|
case 42 /* asterisk */:
|
|
return token = 41 /* AsteriskToken */;
|
|
case 123 /* openBrace */:
|
|
return token = 18 /* OpenBraceToken */;
|
|
case 125 /* closeBrace */:
|
|
return token = 19 /* CloseBraceToken */;
|
|
case 91 /* openBracket */:
|
|
return token = 22 /* OpenBracketToken */;
|
|
case 93 /* closeBracket */:
|
|
return token = 23 /* CloseBracketToken */;
|
|
case 60 /* lessThan */:
|
|
return token = 29 /* LessThanToken */;
|
|
case 62 /* greaterThan */:
|
|
return token = 31 /* GreaterThanToken */;
|
|
case 61 /* equals */:
|
|
return token = 63 /* EqualsToken */;
|
|
case 44 /* comma */:
|
|
return token = 27 /* CommaToken */;
|
|
case 46 /* dot */:
|
|
return token = 24 /* DotToken */;
|
|
case 96 /* backtick */:
|
|
return token = 61 /* BacktickToken */;
|
|
case 35 /* hash */:
|
|
return token = 62 /* HashToken */;
|
|
case 92 /* backslash */:
|
|
pos--;
|
|
const extendedCookedChar = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
const cookedChar = peekUnicodeEscape();
|
|
if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
if (isIdentifierStart(ch, languageVersion)) {
|
|
let char = ch;
|
|
while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45 /* minus */)
|
|
pos += charSize(char);
|
|
tokenValue = text.substring(tokenPos, pos);
|
|
if (char === 92 /* backslash */) {
|
|
tokenValue += scanIdentifierParts();
|
|
}
|
|
return token = getIdentifierToken();
|
|
} else {
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
}
|
|
function speculationHelper(callback, isLookahead) {
|
|
const savePos = pos;
|
|
const saveStartPos = startPos;
|
|
const saveTokenPos = tokenPos;
|
|
const saveToken = token;
|
|
const saveTokenValue = tokenValue;
|
|
const saveTokenFlags = tokenFlags;
|
|
const result = callback();
|
|
if (!result || isLookahead) {
|
|
pos = savePos;
|
|
startPos = saveStartPos;
|
|
tokenPos = saveTokenPos;
|
|
token = saveToken;
|
|
tokenValue = saveTokenValue;
|
|
tokenFlags = saveTokenFlags;
|
|
}
|
|
return result;
|
|
}
|
|
function scanRange(start2, length3, callback) {
|
|
const saveEnd = end;
|
|
const savePos = pos;
|
|
const saveStartPos = startPos;
|
|
const saveTokenPos = tokenPos;
|
|
const saveToken = token;
|
|
const saveTokenValue = tokenValue;
|
|
const saveTokenFlags = tokenFlags;
|
|
const saveErrorExpectations = commentDirectives;
|
|
setText(text, start2, length3);
|
|
const 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, true);
|
|
}
|
|
function tryScan(callback) {
|
|
return speculationHelper(callback, false);
|
|
}
|
|
function getText() {
|
|
return text;
|
|
}
|
|
function clearCommentDirectives() {
|
|
commentDirectives = void 0;
|
|
}
|
|
function setText(newText, start2, length3) {
|
|
text = newText || "";
|
|
end = length3 === void 0 ? text.length : start2 + length3;
|
|
setTextPos(start2 || 0);
|
|
}
|
|
function setOnError(errorCallback) {
|
|
onError = errorCallback;
|
|
}
|
|
function setScriptTarget(scriptTarget) {
|
|
languageVersion = scriptTarget;
|
|
}
|
|
function setLanguageVariant(variant) {
|
|
languageVariant = variant;
|
|
}
|
|
function setTextPos(textPos) {
|
|
Debug.assert(textPos >= 0);
|
|
pos = textPos;
|
|
startPos = textPos;
|
|
tokenPos = textPos;
|
|
token = 0 /* Unknown */;
|
|
tokenValue = void 0;
|
|
tokenFlags = 0 /* None */;
|
|
}
|
|
function setInJSDocType(inType) {
|
|
inJSDocType += inType ? 1 : -1;
|
|
}
|
|
}
|
|
var codePointAt = String.prototype.codePointAt ? (s, i) => s.codePointAt(i) : function codePointAt2(str, i) {
|
|
const size = str.length;
|
|
if (i < 0 || i >= size) {
|
|
return void 0;
|
|
}
|
|
const first2 = str.charCodeAt(i);
|
|
if (first2 >= 55296 && first2 <= 56319 && size > i + 1) {
|
|
const second = str.charCodeAt(i + 1);
|
|
if (second >= 56320 && second <= 57343) {
|
|
return (first2 - 55296) * 1024 + second - 56320 + 65536;
|
|
}
|
|
}
|
|
return first2;
|
|
};
|
|
function charSize(ch) {
|
|
if (ch >= 65536) {
|
|
return 2;
|
|
}
|
|
return 1;
|
|
}
|
|
function utf16EncodeAsStringFallback(codePoint) {
|
|
Debug.assert(0 <= codePoint && codePoint <= 1114111);
|
|
if (codePoint <= 65535) {
|
|
return String.fromCharCode(codePoint);
|
|
}
|
|
const codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 55296;
|
|
const codeUnit2 = (codePoint - 65536) % 1024 + 56320;
|
|
return String.fromCharCode(codeUnit1, codeUnit2);
|
|
}
|
|
var utf16EncodeAsStringWorker = String.fromCodePoint ? (codePoint) => String.fromCodePoint(codePoint) : utf16EncodeAsStringFallback;
|
|
function utf16EncodeAsString(codePoint) {
|
|
return utf16EncodeAsStringWorker(codePoint);
|
|
}
|
|
|
|
// src/compiler/utilitiesPublic.ts
|
|
function isExternalModuleNameRelative(moduleName) {
|
|
return pathIsRelative(moduleName) || isRootedDiskPath(moduleName);
|
|
}
|
|
function sortAndDeduplicateDiagnostics(diagnostics) {
|
|
return sortAndDeduplicate(diagnostics, compareDiagnostics);
|
|
}
|
|
function getDefaultLibFileName(options) {
|
|
switch (getEmitScriptTarget(options)) {
|
|
case 99 /* ESNext */:
|
|
return "lib.esnext.full.d.ts";
|
|
case 9 /* ES2022 */:
|
|
return "lib.es2022.full.d.ts";
|
|
case 8 /* ES2021 */:
|
|
return "lib.es2021.full.d.ts";
|
|
case 7 /* ES2020 */:
|
|
return "lib.es2020.full.d.ts";
|
|
case 6 /* ES2019 */:
|
|
return "lib.es2019.full.d.ts";
|
|
case 5 /* ES2018 */:
|
|
return "lib.es2018.full.d.ts";
|
|
case 4 /* ES2017 */:
|
|
return "lib.es2017.full.d.ts";
|
|
case 3 /* ES2016 */:
|
|
return "lib.es2016.full.d.ts";
|
|
case 2 /* ES2015 */:
|
|
return "lib.es6.d.ts";
|
|
default:
|
|
return "lib.d.ts";
|
|
}
|
|
}
|
|
function textSpanEnd(span) {
|
|
return span.start + span.length;
|
|
}
|
|
function textSpanIsEmpty(span) {
|
|
return span.length === 0;
|
|
}
|
|
function textSpanContainsPosition(span, position) {
|
|
return position >= span.start && position < textSpanEnd(span);
|
|
}
|
|
function textRangeContainsPositionInclusive(span, position) {
|
|
return position >= span.pos && position <= span.end;
|
|
}
|
|
function createTextSpan(start, length2) {
|
|
if (start < 0) {
|
|
throw new Error("start < 0");
|
|
}
|
|
if (length2 < 0) {
|
|
throw new Error("length < 0");
|
|
}
|
|
return { start, length: length2 };
|
|
}
|
|
function createTextSpanFromBounds(start, end) {
|
|
return createTextSpan(start, end - start);
|
|
}
|
|
function textChangeRangeNewSpan(range) {
|
|
return createTextSpan(range.span.start, range.newLength);
|
|
}
|
|
function textChangeRangeIsUnchanged(range) {
|
|
return textSpanIsEmpty(range.span) && range.newLength === 0;
|
|
}
|
|
function createTextChangeRange(span, newLength) {
|
|
if (newLength < 0) {
|
|
throw new Error("newLength < 0");
|
|
}
|
|
return { span, newLength };
|
|
}
|
|
var unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
|
|
function isParameterPropertyDeclaration(node, parent) {
|
|
return hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) && parent.kind === 173 /* Constructor */;
|
|
}
|
|
function walkUpBindingElementsAndPatterns(binding) {
|
|
let node = binding.parent;
|
|
while (isBindingElement(node.parent)) {
|
|
node = node.parent.parent;
|
|
}
|
|
return node.parent;
|
|
}
|
|
function getCombinedFlags(node, getFlags) {
|
|
if (isBindingElement(node)) {
|
|
node = walkUpBindingElementsAndPatterns(node);
|
|
}
|
|
let flags = getFlags(node);
|
|
if (node.kind === 257 /* VariableDeclaration */) {
|
|
node = node.parent;
|
|
}
|
|
if (node && node.kind === 258 /* VariableDeclarationList */) {
|
|
flags |= getFlags(node);
|
|
node = node.parent;
|
|
}
|
|
if (node && node.kind === 240 /* VariableStatement */) {
|
|
flags |= getFlags(node);
|
|
}
|
|
return flags;
|
|
}
|
|
function getCombinedModifierFlags(node) {
|
|
return getCombinedFlags(node, getEffectiveModifierFlags);
|
|
}
|
|
function getCombinedNodeFlags(node) {
|
|
return getCombinedFlags(node, (n) => n.flags);
|
|
}
|
|
var supportedLocaleDirectories = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"];
|
|
function validateLocaleAndSetLanguage(locale, sys2, errors) {
|
|
const lowerCaseLocale = locale.toLowerCase();
|
|
const matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(lowerCaseLocale);
|
|
if (!matchResult) {
|
|
if (errors) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp"));
|
|
}
|
|
return;
|
|
}
|
|
const language = matchResult[1];
|
|
const territory = matchResult[3];
|
|
if (contains(supportedLocaleDirectories, lowerCaseLocale) && !trySetLanguageAndTerritory(language, territory, errors)) {
|
|
trySetLanguageAndTerritory(language, void 0, errors);
|
|
}
|
|
setUILocale(locale);
|
|
function trySetLanguageAndTerritory(language2, territory2, errors2) {
|
|
const compilerFilePath = normalizePath(sys2.getExecutingFilePath());
|
|
const containingDirectoryPath = getDirectoryPath(compilerFilePath);
|
|
let filePath = combinePaths(containingDirectoryPath, language2);
|
|
if (territory2) {
|
|
filePath = filePath + "-" + territory2;
|
|
}
|
|
filePath = sys2.resolvePath(combinePaths(filePath, "diagnosticMessages.generated.json"));
|
|
if (!sys2.fileExists(filePath)) {
|
|
return false;
|
|
}
|
|
let fileContents = "";
|
|
try {
|
|
fileContents = sys2.readFile(filePath);
|
|
} catch (e) {
|
|
if (errors2) {
|
|
errors2.push(createCompilerDiagnostic(Diagnostics.Unable_to_open_file_0, filePath));
|
|
}
|
|
return false;
|
|
}
|
|
try {
|
|
setLocalizedDiagnosticMessages(JSON.parse(fileContents));
|
|
} catch (e) {
|
|
if (errors2) {
|
|
errors2.push(createCompilerDiagnostic(Diagnostics.Corrupted_locale_file_0, filePath));
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function getOriginalNode(node, nodeTest) {
|
|
if (node) {
|
|
while (node.original !== void 0) {
|
|
node = node.original;
|
|
}
|
|
}
|
|
return !nodeTest || nodeTest(node) ? node : void 0;
|
|
}
|
|
function findAncestor(node, callback) {
|
|
while (node) {
|
|
const result = callback(node);
|
|
if (result === "quit") {
|
|
return void 0;
|
|
} else if (result) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isParseTreeNode(node) {
|
|
return (node.flags & 8 /* Synthesized */) === 0;
|
|
}
|
|
function getParseTreeNode(node, nodeTest) {
|
|
if (node === void 0 || isParseTreeNode(node)) {
|
|
return node;
|
|
}
|
|
node = node.original;
|
|
while (node) {
|
|
if (isParseTreeNode(node)) {
|
|
return !nodeTest || nodeTest(node) ? node : void 0;
|
|
}
|
|
node = node.original;
|
|
}
|
|
}
|
|
function escapeLeadingUnderscores(identifier) {
|
|
return identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ ? "_" + identifier : identifier;
|
|
}
|
|
function unescapeLeadingUnderscores(identifier) {
|
|
const id = identifier;
|
|
return id.length >= 3 && id.charCodeAt(0) === 95 /* _ */ && id.charCodeAt(1) === 95 /* _ */ && id.charCodeAt(2) === 95 /* _ */ ? id.substr(1) : id;
|
|
}
|
|
function idText(identifierOrPrivateName) {
|
|
return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText);
|
|
}
|
|
function symbolName(symbol) {
|
|
if (symbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) {
|
|
return idText(symbol.valueDeclaration.name);
|
|
}
|
|
return unescapeLeadingUnderscores(symbol.escapedName);
|
|
}
|
|
function nameForNamelessJSDocTypedef(declaration) {
|
|
const hostNode = declaration.parent.parent;
|
|
if (!hostNode) {
|
|
return void 0;
|
|
}
|
|
if (isDeclaration(hostNode)) {
|
|
return getDeclarationIdentifier(hostNode);
|
|
}
|
|
switch (hostNode.kind) {
|
|
case 240 /* VariableStatement */:
|
|
if (hostNode.declarationList && hostNode.declarationList.declarations[0]) {
|
|
return getDeclarationIdentifier(hostNode.declarationList.declarations[0]);
|
|
}
|
|
break;
|
|
case 241 /* ExpressionStatement */:
|
|
let expr = hostNode.expression;
|
|
if (expr.kind === 223 /* BinaryExpression */ && expr.operatorToken.kind === 63 /* EqualsToken */) {
|
|
expr = expr.left;
|
|
}
|
|
switch (expr.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return expr.name;
|
|
case 209 /* ElementAccessExpression */:
|
|
const arg = expr.argumentExpression;
|
|
if (isIdentifier(arg)) {
|
|
return arg;
|
|
}
|
|
}
|
|
break;
|
|
case 214 /* ParenthesizedExpression */: {
|
|
return getDeclarationIdentifier(hostNode.expression);
|
|
}
|
|
case 253 /* LabeledStatement */: {
|
|
if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) {
|
|
return getDeclarationIdentifier(hostNode.statement);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function getDeclarationIdentifier(node) {
|
|
const name = getNameOfDeclaration(node);
|
|
return name && isIdentifier(name) ? name : void 0;
|
|
}
|
|
function nodeHasName(statement, name) {
|
|
if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) {
|
|
return true;
|
|
}
|
|
if (isVariableStatement(statement) && some(statement.declarationList.declarations, (d) => nodeHasName(d, name))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getNameOfJSDocTypedef(declaration) {
|
|
return declaration.name || nameForNamelessJSDocTypedef(declaration);
|
|
}
|
|
function isNamedDeclaration(node) {
|
|
return !!node.name;
|
|
}
|
|
function getNonAssignedNameOfDeclaration(declaration) {
|
|
switch (declaration.kind) {
|
|
case 79 /* Identifier */:
|
|
return declaration;
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 343 /* JSDocParameterTag */: {
|
|
const { name } = declaration;
|
|
if (name.kind === 163 /* QualifiedName */) {
|
|
return name.right;
|
|
}
|
|
break;
|
|
}
|
|
case 210 /* CallExpression */:
|
|
case 223 /* BinaryExpression */: {
|
|
const expr2 = declaration;
|
|
switch (getAssignmentDeclarationKind(expr2)) {
|
|
case 1 /* ExportsProperty */:
|
|
case 4 /* ThisProperty */:
|
|
case 5 /* Property */:
|
|
case 3 /* PrototypeProperty */:
|
|
return getElementOrPropertyAccessArgumentExpressionOrName(expr2.left);
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return expr2.arguments[1];
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
case 348 /* JSDocTypedefTag */:
|
|
return getNameOfJSDocTypedef(declaration);
|
|
case 342 /* JSDocEnumTag */:
|
|
return nameForNamelessJSDocTypedef(declaration);
|
|
case 274 /* ExportAssignment */: {
|
|
const { expression } = declaration;
|
|
return isIdentifier(expression) ? expression : void 0;
|
|
}
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = declaration;
|
|
if (isBindableStaticElementAccessExpression(expr)) {
|
|
return expr.argumentExpression;
|
|
}
|
|
}
|
|
return declaration.name;
|
|
}
|
|
function getNameOfDeclaration(declaration) {
|
|
if (declaration === void 0)
|
|
return void 0;
|
|
return getNonAssignedNameOfDeclaration(declaration) || (isFunctionExpression(declaration) || isArrowFunction(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : void 0);
|
|
}
|
|
function getAssignedName(node) {
|
|
if (!node.parent) {
|
|
return void 0;
|
|
} else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) {
|
|
return node.parent.name;
|
|
} else if (isBinaryExpression(node.parent) && node === node.parent.right) {
|
|
if (isIdentifier(node.parent.left)) {
|
|
return node.parent.left;
|
|
} else if (isAccessExpression(node.parent.left)) {
|
|
return getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left);
|
|
}
|
|
} else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) {
|
|
return node.parent.name;
|
|
}
|
|
}
|
|
function getDecorators(node) {
|
|
if (hasDecorators(node)) {
|
|
return filter(node.modifiers, isDecorator);
|
|
}
|
|
}
|
|
function getModifiers(node) {
|
|
if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
|
|
return filter(node.modifiers, isModifier);
|
|
}
|
|
}
|
|
function getJSDocParameterTagsWorker(param, noCache) {
|
|
if (param.name) {
|
|
if (isIdentifier(param.name)) {
|
|
const name = param.name.escapedText;
|
|
return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
|
|
} else {
|
|
const i = param.parent.parameters.indexOf(param);
|
|
Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
|
|
const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
|
|
if (i < paramTags.length) {
|
|
return [paramTags[i]];
|
|
}
|
|
}
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getJSDocParameterTags(param) {
|
|
return getJSDocParameterTagsWorker(param, false);
|
|
}
|
|
function getJSDocParameterTagsNoCache(param) {
|
|
return getJSDocParameterTagsWorker(param, true);
|
|
}
|
|
function getJSDocTypeParameterTagsWorker(param, noCache) {
|
|
const name = param.name.escapedText;
|
|
return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocTemplateTag(tag) && tag.typeParameters.some((tp) => tp.name.escapedText === name));
|
|
}
|
|
function getJSDocTypeParameterTags(param) {
|
|
return getJSDocTypeParameterTagsWorker(param, false);
|
|
}
|
|
function getJSDocTypeParameterTagsNoCache(param) {
|
|
return getJSDocTypeParameterTagsWorker(param, true);
|
|
}
|
|
function hasJSDocParameterTags(node) {
|
|
return !!getFirstJSDocTag(node, isJSDocParameterTag);
|
|
}
|
|
function getJSDocAugmentsTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocAugmentsTag);
|
|
}
|
|
function getJSDocImplementsTags(node) {
|
|
return getAllJSDocTags(node, isJSDocImplementsTag);
|
|
}
|
|
function getJSDocClassTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocClassTag);
|
|
}
|
|
function getJSDocPublicTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocPublicTag, true);
|
|
}
|
|
function getJSDocPrivateTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocPrivateTag, true);
|
|
}
|
|
function getJSDocProtectedTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocProtectedTag, true);
|
|
}
|
|
function getJSDocReadonlyTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocReadonlyTag, true);
|
|
}
|
|
function getJSDocOverrideTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocOverrideTag, true);
|
|
}
|
|
function getJSDocDeprecatedTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocDeprecatedTag);
|
|
}
|
|
function getJSDocDeprecatedTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocDeprecatedTag, true);
|
|
}
|
|
function getJSDocEnumTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocEnumTag);
|
|
}
|
|
function getJSDocThisTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocThisTag);
|
|
}
|
|
function getJSDocReturnTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocReturnTag);
|
|
}
|
|
function getJSDocTypeTag(node) {
|
|
const tag = getFirstJSDocTag(node, isJSDocTypeTag);
|
|
if (tag && tag.typeExpression && tag.typeExpression.type) {
|
|
return tag;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getJSDocType(node) {
|
|
let tag = getFirstJSDocTag(node, isJSDocTypeTag);
|
|
if (!tag && isParameter(node)) {
|
|
tag = find(getJSDocParameterTags(node), (tag2) => !!tag2.typeExpression);
|
|
}
|
|
return tag && tag.typeExpression && tag.typeExpression.type;
|
|
}
|
|
function getJSDocReturnType(node) {
|
|
const returnTag = getJSDocReturnTag(node);
|
|
if (returnTag && returnTag.typeExpression) {
|
|
return returnTag.typeExpression.type;
|
|
}
|
|
const typeTag = getJSDocTypeTag(node);
|
|
if (typeTag && typeTag.typeExpression) {
|
|
const type = typeTag.typeExpression.type;
|
|
if (isTypeLiteralNode(type)) {
|
|
const sig = find(type.members, isCallSignatureDeclaration);
|
|
return sig && sig.type;
|
|
}
|
|
if (isFunctionTypeNode(type) || isJSDocFunctionType(type)) {
|
|
return type.type;
|
|
}
|
|
}
|
|
}
|
|
function getJSDocTagsWorker(node, noCache) {
|
|
let tags = node.jsDocCache;
|
|
if (tags === void 0 || noCache) {
|
|
const comments = getJSDocCommentsAndTags(node, noCache);
|
|
Debug.assert(comments.length < 2 || comments[0] !== comments[1]);
|
|
tags = flatMap(comments, (j) => isJSDoc(j) ? j.tags : j);
|
|
if (!noCache) {
|
|
node.jsDocCache = tags;
|
|
}
|
|
}
|
|
return tags;
|
|
}
|
|
function getJSDocTags(node) {
|
|
return getJSDocTagsWorker(node, false);
|
|
}
|
|
function getFirstJSDocTag(node, predicate, noCache) {
|
|
return find(getJSDocTagsWorker(node, noCache), predicate);
|
|
}
|
|
function getAllJSDocTags(node, predicate) {
|
|
return getJSDocTags(node).filter(predicate);
|
|
}
|
|
function getTextOfJSDocComment(comment) {
|
|
return typeof comment === "string" ? comment : comment == null ? void 0 : comment.map((c) => c.kind === 324 /* JSDocText */ ? c.text : formatJSDocLink(c)).join("");
|
|
}
|
|
function formatJSDocLink(link) {
|
|
const kind = link.kind === 327 /* JSDocLink */ ? "link" : link.kind === 328 /* JSDocLinkCode */ ? "linkcode" : "linkplain";
|
|
const name = link.name ? entityNameToString(link.name) : "";
|
|
const space = link.name && link.text.startsWith("://") ? "" : " ";
|
|
return `{@${kind} ${name}${space}${link.text}}`;
|
|
}
|
|
function getEffectiveTypeParameterDeclarations(node) {
|
|
if (isJSDocSignature(node)) {
|
|
return emptyArray;
|
|
}
|
|
if (isJSDocTypeAlias(node)) {
|
|
Debug.assert(node.parent.kind === 323 /* JSDoc */);
|
|
return flatMap(node.parent.tags, (tag) => isJSDocTemplateTag(tag) ? tag.typeParameters : void 0);
|
|
}
|
|
if (node.typeParameters) {
|
|
return node.typeParameters;
|
|
}
|
|
if (canHaveIllegalTypeParameters(node) && node.typeParameters) {
|
|
return node.typeParameters;
|
|
}
|
|
if (isInJSFile(node)) {
|
|
const decls = getJSDocTypeParameterDeclarations(node);
|
|
if (decls.length) {
|
|
return decls;
|
|
}
|
|
const typeTag = getJSDocType(node);
|
|
if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) {
|
|
return typeTag.typeParameters;
|
|
}
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getEffectiveConstraintOfTypeParameter(node) {
|
|
return node.constraint ? node.constraint : isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint : void 0;
|
|
}
|
|
function isMemberName(node) {
|
|
return node.kind === 79 /* Identifier */ || node.kind === 80 /* PrivateIdentifier */;
|
|
}
|
|
function isGetOrSetAccessorDeclaration(node) {
|
|
return node.kind === 175 /* SetAccessor */ || node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function isPropertyAccessChain(node) {
|
|
return isPropertyAccessExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isElementAccessChain(node) {
|
|
return isElementAccessExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isCallChain(node) {
|
|
return isCallExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isOptionalChain(node) {
|
|
const kind = node.kind;
|
|
return !!(node.flags & 32 /* OptionalChain */) && (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */ || kind === 210 /* CallExpression */ || kind === 232 /* NonNullExpression */);
|
|
}
|
|
function isOptionalChainRoot(node) {
|
|
return isOptionalChain(node) && !isNonNullExpression(node) && !!node.questionDotToken;
|
|
}
|
|
function isExpressionOfOptionalChainRoot(node) {
|
|
return isOptionalChainRoot(node.parent) && node.parent.expression === node;
|
|
}
|
|
function isOutermostOptionalChain(node) {
|
|
return !isOptionalChain(node.parent) || isOptionalChainRoot(node.parent) || node !== node.parent.expression;
|
|
}
|
|
function isNullishCoalesce(node) {
|
|
return node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 60 /* QuestionQuestionToken */;
|
|
}
|
|
function isConstTypeReference(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "const" && !node.typeArguments;
|
|
}
|
|
function skipPartiallyEmittedExpressions(node) {
|
|
return skipOuterExpressions(node, 8 /* PartiallyEmittedExpressions */);
|
|
}
|
|
function isNonNullChain(node) {
|
|
return isNonNullExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isNamedExportBindings(node) {
|
|
return node.kind === 277 /* NamespaceExport */ || node.kind === 276 /* NamedExports */;
|
|
}
|
|
function isUnparsedTextLike(node) {
|
|
switch (node.kind) {
|
|
case 305 /* UnparsedText */:
|
|
case 306 /* UnparsedInternalText */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isUnparsedNode(node) {
|
|
return isUnparsedTextLike(node) || node.kind === 303 /* UnparsedPrologue */ || node.kind === 307 /* UnparsedSyntheticReference */;
|
|
}
|
|
function isJSDocPropertyLikeTag(node) {
|
|
return node.kind === 350 /* JSDocPropertyTag */ || node.kind === 343 /* JSDocParameterTag */;
|
|
}
|
|
function isNodeKind(kind) {
|
|
return kind >= 163 /* FirstNode */;
|
|
}
|
|
function isTokenKind(kind) {
|
|
return kind >= 0 /* FirstToken */ && kind <= 162 /* LastToken */;
|
|
}
|
|
function isToken(n) {
|
|
return isTokenKind(n.kind);
|
|
}
|
|
function isNodeArray(array) {
|
|
return hasProperty(array, "pos") && hasProperty(array, "end");
|
|
}
|
|
function isLiteralKind(kind) {
|
|
return 8 /* FirstLiteralToken */ <= kind && kind <= 14 /* LastLiteralToken */;
|
|
}
|
|
function isLiteralExpression(node) {
|
|
return isLiteralKind(node.kind);
|
|
}
|
|
function isLiteralExpressionOfObject(node) {
|
|
switch (node.kind) {
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTemplateLiteralKind(kind) {
|
|
return 14 /* FirstTemplateToken */ <= kind && kind <= 17 /* LastTemplateToken */;
|
|
}
|
|
function isTemplateMiddleOrTemplateTail(node) {
|
|
const kind = node.kind;
|
|
return kind === 16 /* TemplateMiddle */ || kind === 17 /* TemplateTail */;
|
|
}
|
|
function isImportOrExportSpecifier(node) {
|
|
return isImportSpecifier(node) || isExportSpecifier(node);
|
|
}
|
|
function isTypeOnlyImportOrExportDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return node.isTypeOnly || node.parent.parent.isTypeOnly;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.isTypeOnly;
|
|
case 270 /* ImportClause */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.isTypeOnly;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isAssertionKey(node) {
|
|
return isStringLiteral(node) || isIdentifier(node);
|
|
}
|
|
function isGeneratedIdentifier(node) {
|
|
return isIdentifier(node) && (node.autoGenerateFlags & 7 /* KindMask */) > 0 /* None */;
|
|
}
|
|
function isGeneratedPrivateIdentifier(node) {
|
|
return isPrivateIdentifier(node) && (node.autoGenerateFlags & 7 /* KindMask */) > 0 /* None */;
|
|
}
|
|
function isPrivateIdentifierClassElementDeclaration(node) {
|
|
return (isPropertyDeclaration(node) || isMethodOrAccessor(node)) && isPrivateIdentifier(node.name);
|
|
}
|
|
function isPrivateIdentifierPropertyAccessExpression(node) {
|
|
return isPropertyAccessExpression(node) && isPrivateIdentifier(node.name);
|
|
}
|
|
function isModifierKind(token) {
|
|
switch (token) {
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 132 /* AsyncKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isParameterPropertyModifier(kind) {
|
|
return !!(modifierToFlag(kind) & 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isClassMemberModifier(idToken) {
|
|
return isParameterPropertyModifier(idToken) || idToken === 124 /* StaticKeyword */ || idToken === 161 /* OverrideKeyword */ || idToken === 127 /* AccessorKeyword */;
|
|
}
|
|
function isModifier(node) {
|
|
return isModifierKind(node.kind);
|
|
}
|
|
function isEntityName(node) {
|
|
const kind = node.kind;
|
|
return kind === 163 /* QualifiedName */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isPropertyName(node) {
|
|
const kind = node.kind;
|
|
return kind === 79 /* Identifier */ || kind === 80 /* PrivateIdentifier */ || kind === 10 /* StringLiteral */ || kind === 8 /* NumericLiteral */ || kind === 164 /* ComputedPropertyName */;
|
|
}
|
|
function isBindingName(node) {
|
|
const kind = node.kind;
|
|
return kind === 79 /* Identifier */ || kind === 203 /* ObjectBindingPattern */ || kind === 204 /* ArrayBindingPattern */;
|
|
}
|
|
function isFunctionLike(node) {
|
|
return !!node && isFunctionLikeKind(node.kind);
|
|
}
|
|
function isFunctionLikeOrClassStaticBlockDeclaration(node) {
|
|
return !!node && (isFunctionLikeKind(node.kind) || isClassStaticBlockDeclaration(node));
|
|
}
|
|
function isFunctionLikeDeclaration(node) {
|
|
return node && isFunctionLikeDeclarationKind(node.kind);
|
|
}
|
|
function isFunctionLikeDeclarationKind(kind) {
|
|
switch (kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isFunctionLikeKind(kind) {
|
|
switch (kind) {
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return true;
|
|
default:
|
|
return isFunctionLikeDeclarationKind(kind);
|
|
}
|
|
}
|
|
function isFunctionOrModuleBlock(node) {
|
|
return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent);
|
|
}
|
|
function isClassElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 169 /* PropertyDeclaration */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 178 /* IndexSignature */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 237 /* SemicolonClassElement */;
|
|
}
|
|
function isClassLike(node) {
|
|
return node && (node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */);
|
|
}
|
|
function isAccessor(node) {
|
|
return node && (node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */);
|
|
}
|
|
function isAutoAccessorPropertyDeclaration(node) {
|
|
return isPropertyDeclaration(node) && hasAccessorModifier(node);
|
|
}
|
|
function isMethodOrAccessor(node) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isModifierLike(node) {
|
|
return isModifier(node) || isDecorator(node);
|
|
}
|
|
function isTypeElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 177 /* ConstructSignature */ || kind === 176 /* CallSignature */ || kind === 168 /* PropertySignature */ || kind === 170 /* MethodSignature */ || kind === 178 /* IndexSignature */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function isObjectLiteralElementLike(node) {
|
|
const kind = node.kind;
|
|
return kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 301 /* SpreadAssignment */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function isTypeNode(node) {
|
|
return isTypeNodeKind(node.kind);
|
|
}
|
|
function isFunctionOrConstructorTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isBindingPattern(node) {
|
|
if (node) {
|
|
const kind = node.kind;
|
|
return kind === 204 /* ArrayBindingPattern */ || kind === 203 /* ObjectBindingPattern */;
|
|
}
|
|
return false;
|
|
}
|
|
function isAssignmentPattern(node) {
|
|
const kind = node.kind;
|
|
return kind === 206 /* ArrayLiteralExpression */ || kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isArrayBindingElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 205 /* BindingElement */ || kind === 229 /* OmittedExpression */;
|
|
}
|
|
function isDeclarationBindingElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isBindingOrAssignmentPattern(node) {
|
|
return isObjectBindingOrAssignmentPattern(node) || isArrayBindingOrAssignmentPattern(node);
|
|
}
|
|
function isObjectBindingOrAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isObjectBindingOrAssignmentElement(node) {
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isArrayBindingOrAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
|
|
const kind = node.kind;
|
|
return kind === 208 /* PropertyAccessExpression */ || kind === 163 /* QualifiedName */ || kind === 202 /* ImportType */;
|
|
}
|
|
function isCallLikeExpression(node) {
|
|
switch (node.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 167 /* Decorator */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isCallOrNewExpression(node) {
|
|
return node.kind === 210 /* CallExpression */ || node.kind === 211 /* NewExpression */;
|
|
}
|
|
function isTemplateLiteral(node) {
|
|
const kind = node.kind;
|
|
return kind === 225 /* TemplateExpression */ || kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isLeftHandSideExpression(node) {
|
|
return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isLeftHandSideExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 210 /* CallExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 108 /* ThisKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 232 /* NonNullExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 233 /* MetaProperty */:
|
|
case 100 /* ImportKeyword */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isUnaryExpression(node) {
|
|
return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isUnaryExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
return true;
|
|
default:
|
|
return isLeftHandSideExpressionKind(kind);
|
|
}
|
|
}
|
|
function isExpression(node) {
|
|
return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 224 /* ConditionalExpression */:
|
|
case 226 /* YieldExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 223 /* BinaryExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 231 /* AsExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 354 /* CommaListExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return true;
|
|
default:
|
|
return isUnaryExpressionKind(kind);
|
|
}
|
|
}
|
|
function isAssertionExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 213 /* TypeAssertionExpression */ || kind === 231 /* AsExpression */;
|
|
}
|
|
function isIterationStatement(node, lookInLabeledStatements) {
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return true;
|
|
case 253 /* LabeledStatement */:
|
|
return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements);
|
|
}
|
|
return false;
|
|
}
|
|
function isScopeMarker(node) {
|
|
return isExportAssignment(node) || isExportDeclaration(node);
|
|
}
|
|
function hasScopeMarker(statements) {
|
|
return some(statements, isScopeMarker);
|
|
}
|
|
function needsScopeMarker(result) {
|
|
return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 1 /* Export */) && !isAmbientModule(result);
|
|
}
|
|
function isExternalModuleIndicator(result) {
|
|
return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 1 /* Export */);
|
|
}
|
|
function isForInOrOfStatement(node) {
|
|
return node.kind === 246 /* ForInStatement */ || node.kind === 247 /* ForOfStatement */;
|
|
}
|
|
function isConciseBody(node) {
|
|
return isBlock(node) || isExpression(node);
|
|
}
|
|
function isForInitializer(node) {
|
|
return isVariableDeclarationList(node) || isExpression(node);
|
|
}
|
|
function isModuleBody(node) {
|
|
const kind = node.kind;
|
|
return kind === 265 /* ModuleBlock */ || kind === 264 /* ModuleDeclaration */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isNamedImportBindings(node) {
|
|
const kind = node.kind;
|
|
return kind === 272 /* NamedImports */ || kind === 271 /* NamespaceImport */;
|
|
}
|
|
function isModuleOrEnumDeclaration(node) {
|
|
return node.kind === 264 /* ModuleDeclaration */ || node.kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function isDeclarationKind(kind) {
|
|
return kind === 216 /* ArrowFunction */ || kind === 205 /* BindingElement */ || kind === 260 /* ClassDeclaration */ || kind === 228 /* ClassExpression */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 173 /* Constructor */ || kind === 263 /* EnumDeclaration */ || kind === 302 /* EnumMember */ || kind === 278 /* ExportSpecifier */ || kind === 259 /* FunctionDeclaration */ || kind === 215 /* FunctionExpression */ || kind === 174 /* GetAccessor */ || kind === 270 /* ImportClause */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 273 /* ImportSpecifier */ || kind === 261 /* InterfaceDeclaration */ || kind === 288 /* JsxAttribute */ || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 264 /* ModuleDeclaration */ || kind === 267 /* NamespaceExportDeclaration */ || kind === 271 /* NamespaceImport */ || kind === 277 /* NamespaceExport */ || kind === 166 /* Parameter */ || kind === 299 /* PropertyAssignment */ || kind === 169 /* PropertyDeclaration */ || kind === 168 /* PropertySignature */ || kind === 175 /* SetAccessor */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 262 /* TypeAliasDeclaration */ || kind === 165 /* TypeParameter */ || kind === 257 /* VariableDeclaration */ || kind === 348 /* JSDocTypedefTag */ || kind === 341 /* JSDocCallbackTag */ || kind === 350 /* JSDocPropertyTag */;
|
|
}
|
|
function isDeclarationStatementKind(kind) {
|
|
return kind === 259 /* FunctionDeclaration */ || kind === 279 /* MissingDeclaration */ || kind === 260 /* ClassDeclaration */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 275 /* ExportDeclaration */ || kind === 274 /* ExportAssignment */ || kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
function isStatementKindButNotDeclarationKind(kind) {
|
|
return kind === 249 /* BreakStatement */ || kind === 248 /* ContinueStatement */ || kind === 256 /* DebuggerStatement */ || kind === 243 /* DoStatement */ || kind === 241 /* ExpressionStatement */ || kind === 239 /* EmptyStatement */ || kind === 246 /* ForInStatement */ || kind === 247 /* ForOfStatement */ || kind === 245 /* ForStatement */ || kind === 242 /* IfStatement */ || kind === 253 /* LabeledStatement */ || kind === 250 /* ReturnStatement */ || kind === 252 /* SwitchStatement */ || kind === 254 /* ThrowStatement */ || kind === 255 /* TryStatement */ || kind === 240 /* VariableStatement */ || kind === 244 /* WhileStatement */ || kind === 251 /* WithStatement */ || kind === 352 /* NotEmittedStatement */ || kind === 356 /* EndOfDeclarationMarker */ || kind === 355 /* MergeDeclarationMarker */;
|
|
}
|
|
function isDeclaration(node) {
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
return node.parent && node.parent.kind !== 347 /* JSDocTemplateTag */ || isInJSFile(node);
|
|
}
|
|
return isDeclarationKind(node.kind);
|
|
}
|
|
function isDeclarationStatement(node) {
|
|
return isDeclarationStatementKind(node.kind);
|
|
}
|
|
function isStatementButNotDeclaration(node) {
|
|
return isStatementKindButNotDeclarationKind(node.kind);
|
|
}
|
|
function isStatement(node) {
|
|
const kind = node.kind;
|
|
return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || isBlockStatement(node);
|
|
}
|
|
function isBlockStatement(node) {
|
|
if (node.kind !== 238 /* Block */)
|
|
return false;
|
|
if (node.parent !== void 0) {
|
|
if (node.parent.kind === 255 /* TryStatement */ || node.parent.kind === 295 /* CatchClause */) {
|
|
return false;
|
|
}
|
|
}
|
|
return !isFunctionBlock(node);
|
|
}
|
|
function isStatementOrBlock(node) {
|
|
const kind = node.kind;
|
|
return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || kind === 238 /* Block */;
|
|
}
|
|
function isModuleReference(node) {
|
|
const kind = node.kind;
|
|
return kind === 280 /* ExternalModuleReference */ || kind === 163 /* QualifiedName */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isJsxTagNameExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 108 /* ThisKeyword */ || kind === 79 /* Identifier */ || kind === 208 /* PropertyAccessExpression */;
|
|
}
|
|
function isJsxChild(node) {
|
|
const kind = node.kind;
|
|
return kind === 281 /* JsxElement */ || kind === 291 /* JsxExpression */ || kind === 282 /* JsxSelfClosingElement */ || kind === 11 /* JsxText */ || kind === 285 /* JsxFragment */;
|
|
}
|
|
function isJsxAttributeLike(node) {
|
|
const kind = node.kind;
|
|
return kind === 288 /* JsxAttribute */ || kind === 290 /* JsxSpreadAttribute */;
|
|
}
|
|
function isStringLiteralOrJsxExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 10 /* StringLiteral */ || kind === 291 /* JsxExpression */;
|
|
}
|
|
function isJsxOpeningLikeElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 283 /* JsxOpeningElement */ || kind === 282 /* JsxSelfClosingElement */;
|
|
}
|
|
function isCaseOrDefaultClause(node) {
|
|
const kind = node.kind;
|
|
return kind === 292 /* CaseClause */ || kind === 293 /* DefaultClause */;
|
|
}
|
|
function isJSDocNode(node) {
|
|
return node.kind >= 312 /* FirstJSDocNode */ && node.kind <= 350 /* LastJSDocNode */;
|
|
}
|
|
function isJSDocTag(node) {
|
|
return node.kind >= 330 /* FirstJSDocTagNode */ && node.kind <= 350 /* LastJSDocTagNode */;
|
|
}
|
|
function isSetAccessor(node) {
|
|
return node.kind === 175 /* SetAccessor */;
|
|
}
|
|
function isGetAccessor(node) {
|
|
return node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function hasJSDocNodes(node) {
|
|
const { jsDoc } = node;
|
|
return !!jsDoc && jsDoc.length > 0;
|
|
}
|
|
function hasType(node) {
|
|
return !!node.type;
|
|
}
|
|
function hasInitializer(node) {
|
|
return !!node.initializer;
|
|
}
|
|
function hasOnlyExpressionInitializer(node) {
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 302 /* EnumMember */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isObjectLiteralElement(node) {
|
|
return node.kind === 288 /* JsxAttribute */ || node.kind === 290 /* JsxSpreadAttribute */ || isObjectLiteralElementLike(node);
|
|
}
|
|
function isTypeReferenceType(node) {
|
|
return node.kind === 180 /* TypeReference */ || node.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
var MAX_SMI_X86 = 1073741823;
|
|
function guessIndentation(lines) {
|
|
let indentation = MAX_SMI_X86;
|
|
for (const line of lines) {
|
|
if (!line.length) {
|
|
continue;
|
|
}
|
|
let i = 0;
|
|
for (; i < line.length && i < indentation; i++) {
|
|
if (!isWhiteSpaceLike(line.charCodeAt(i))) {
|
|
break;
|
|
}
|
|
}
|
|
if (i < indentation) {
|
|
indentation = i;
|
|
}
|
|
if (indentation === 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
return indentation === MAX_SMI_X86 ? void 0 : indentation;
|
|
}
|
|
function isStringLiteralLike(node) {
|
|
return node.kind === 10 /* StringLiteral */ || node.kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isJSDocLinkLike(node) {
|
|
return node.kind === 327 /* JSDocLink */ || node.kind === 328 /* JSDocLinkCode */ || node.kind === 329 /* JSDocLinkPlain */;
|
|
}
|
|
function hasRestParameter(s) {
|
|
const last2 = lastOrUndefined(s.parameters);
|
|
return !!last2 && isRestParameter(last2);
|
|
}
|
|
function isRestParameter(node) {
|
|
const type = isJSDocParameterTag(node) ? node.typeExpression && node.typeExpression.type : node.type;
|
|
return node.dotDotDotToken !== void 0 || !!type && type.kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
|
|
// src/compiler/utilities.ts
|
|
var resolvingEmptyArray = [];
|
|
var externalHelpersModuleNameText = "tslib";
|
|
var defaultMaximumTruncationLength = 160;
|
|
var noTruncationMaximumTruncationLength = 1e6;
|
|
function getDeclarationOfKind(symbol, kind) {
|
|
const declarations = symbol.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
if (declaration.kind === kind) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDeclarationsOfKind(symbol, kind) {
|
|
return filter(symbol.declarations || emptyArray, (d) => d.kind === kind);
|
|
}
|
|
function createSymbolTable(symbols) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
if (symbols) {
|
|
for (const symbol of symbols) {
|
|
result.set(symbol.escapedName, symbol);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function isTransientSymbol(symbol) {
|
|
return (symbol.flags & 33554432 /* Transient */) !== 0;
|
|
}
|
|
var stringWriter = createSingleLineStringWriter();
|
|
function createSingleLineStringWriter() {
|
|
let str = "";
|
|
const writeText = (text) => str += text;
|
|
return {
|
|
getText: () => str,
|
|
write: writeText,
|
|
rawWrite: writeText,
|
|
writeKeyword: writeText,
|
|
writeOperator: writeText,
|
|
writePunctuation: writeText,
|
|
writeSpace: writeText,
|
|
writeStringLiteral: writeText,
|
|
writeLiteral: writeText,
|
|
writeParameter: writeText,
|
|
writeProperty: writeText,
|
|
writeSymbol: (s, _) => writeText(s),
|
|
writeTrailingSemicolon: writeText,
|
|
writeComment: writeText,
|
|
getTextPos: () => str.length,
|
|
getLine: () => 0,
|
|
getColumn: () => 0,
|
|
getIndent: () => 0,
|
|
isAtStartOfLine: () => false,
|
|
hasTrailingComment: () => false,
|
|
hasTrailingWhitespace: () => !!str.length && isWhiteSpaceLike(str.charCodeAt(str.length - 1)),
|
|
writeLine: () => str += " ",
|
|
increaseIndent: noop,
|
|
decreaseIndent: noop,
|
|
clear: () => str = "",
|
|
trackSymbol: () => false,
|
|
reportInaccessibleThisError: noop,
|
|
reportInaccessibleUniqueSymbolError: noop,
|
|
reportPrivateInBaseOfClassExpression: noop
|
|
};
|
|
}
|
|
function changesAffectModuleResolution(oldOptions, newOptions) {
|
|
return oldOptions.configFilePath !== newOptions.configFilePath || optionsHaveModuleResolutionChanges(oldOptions, newOptions);
|
|
}
|
|
function optionsHaveModuleResolutionChanges(oldOptions, newOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, moduleResolutionOptionDeclarations);
|
|
}
|
|
function changesAffectingProgramStructure(oldOptions, newOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, optionsAffectingProgramStructure);
|
|
}
|
|
function optionsHaveChanges(oldOptions, newOptions, optionDeclarations2) {
|
|
return oldOptions !== newOptions && optionDeclarations2.some((o) => !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)));
|
|
}
|
|
function forEachEntry(map2, callback) {
|
|
const iterator = map2.entries();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
const [key, value] = iterResult.value;
|
|
const result = callback(value, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function forEachKey(map2, callback) {
|
|
const iterator = map2.keys();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
const result = callback(iterResult.value);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function copyEntries(source, target) {
|
|
source.forEach((value, key) => {
|
|
target.set(key, value);
|
|
});
|
|
}
|
|
function usingSingleLineStringWriter(action) {
|
|
const oldString = stringWriter.getText();
|
|
try {
|
|
action(stringWriter);
|
|
return stringWriter.getText();
|
|
} finally {
|
|
stringWriter.clear();
|
|
stringWriter.writeKeyword(oldString);
|
|
}
|
|
}
|
|
function getFullWidth(node) {
|
|
return node.end - node.pos;
|
|
}
|
|
function getResolvedModule(sourceFile, moduleNameText, mode) {
|
|
return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
|
|
}
|
|
function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
|
|
if (!sourceFile.resolvedModules) {
|
|
sourceFile.resolvedModules = createModeAwareCache();
|
|
}
|
|
sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);
|
|
}
|
|
function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective, mode) {
|
|
if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
|
|
sourceFile.resolvedTypeReferenceDirectiveNames = createModeAwareCache();
|
|
}
|
|
sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, mode, resolvedTypeReferenceDirective);
|
|
}
|
|
function getResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, mode) {
|
|
var _a2;
|
|
return (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode);
|
|
}
|
|
function projectReferenceIsEqualTo(oldRef, newRef) {
|
|
return oldRef.path === newRef.path && !oldRef.prepend === !newRef.prepend && !oldRef.circular === !newRef.circular;
|
|
}
|
|
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);
|
|
}
|
|
function packageIdIsEqual(a, b) {
|
|
return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;
|
|
}
|
|
function packageIdToPackageName({ name, subModuleName }) {
|
|
return subModuleName ? `${name}/${subModuleName}` : name;
|
|
}
|
|
function packageIdToString(packageId) {
|
|
return `${packageIdToPackageName(packageId)}@${packageId.version}`;
|
|
}
|
|
function typeDirectiveIsEqualTo(oldResolution, newResolution) {
|
|
return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary && oldResolution.originalPath === newResolution.originalPath;
|
|
}
|
|
function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer) {
|
|
Debug.assert(names.length === newResolutions.length);
|
|
for (let i = 0; i < names.length; i++) {
|
|
const newResolution = newResolutions[i];
|
|
const entry = names[i];
|
|
const name = getResolutionName(entry);
|
|
const mode = getResolutionMode(entry, newSourceFile);
|
|
const oldResolution = oldResolutions && oldResolutions.get(name, mode);
|
|
const changed = oldResolution ? !newResolution || !comparer(oldResolution, newResolution) : newResolution;
|
|
if (changed) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function containsParseError(node) {
|
|
aggregateChildData(node);
|
|
return (node.flags & 524288 /* ThisNodeOrAnySubNodesHasError */) !== 0;
|
|
}
|
|
function aggregateChildData(node) {
|
|
if (!(node.flags & 1048576 /* HasAggregatedChildData */)) {
|
|
const thisNodeOrAnySubNodesHasError = (node.flags & 131072 /* ThisNodeHasError */) !== 0 || forEachChild(node, containsParseError);
|
|
if (thisNodeOrAnySubNodesHasError) {
|
|
node.flags |= 524288 /* ThisNodeOrAnySubNodesHasError */;
|
|
}
|
|
node.flags |= 1048576 /* HasAggregatedChildData */;
|
|
}
|
|
}
|
|
function getSourceFileOfNode(node) {
|
|
while (node && node.kind !== 308 /* SourceFile */) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function getSourceFileOfModule(module2) {
|
|
return getSourceFileOfNode(module2.valueDeclaration || getNonAugmentationDeclaration(module2));
|
|
}
|
|
function isPlainJsFile(file, checkJs) {
|
|
return !!file && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */) && !file.checkJsDirective && checkJs === void 0;
|
|
}
|
|
function isStatementWithLocals(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 266 /* CaseBlock */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getEndLinePosition(line, sourceFile) {
|
|
Debug.assert(line >= 0);
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
const lineIndex = line;
|
|
const sourceText = sourceFile.text;
|
|
if (lineIndex + 1 === lineStarts.length) {
|
|
return sourceText.length - 1;
|
|
} else {
|
|
const start = lineStarts[lineIndex];
|
|
let pos = lineStarts[lineIndex + 1] - 1;
|
|
Debug.assert(isLineBreak(sourceText.charCodeAt(pos)));
|
|
while (start <= pos && isLineBreak(sourceText.charCodeAt(pos))) {
|
|
pos--;
|
|
}
|
|
return pos;
|
|
}
|
|
}
|
|
function isFileLevelUniqueName(sourceFile, name, hasGlobalName) {
|
|
return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name);
|
|
}
|
|
function nodeIsMissing(node) {
|
|
if (node === void 0) {
|
|
return true;
|
|
}
|
|
return node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* EndOfFileToken */;
|
|
}
|
|
function nodeIsPresent(node) {
|
|
return !nodeIsMissing(node);
|
|
}
|
|
function insertStatementsAfterPrologue(to, from, isPrologueDirective2) {
|
|
if (from === void 0 || from.length === 0)
|
|
return to;
|
|
let statementIndex = 0;
|
|
for (; statementIndex < to.length; ++statementIndex) {
|
|
if (!isPrologueDirective2(to[statementIndex])) {
|
|
break;
|
|
}
|
|
}
|
|
to.splice(statementIndex, 0, ...from);
|
|
return to;
|
|
}
|
|
function insertStatementAfterPrologue(to, statement, isPrologueDirective2) {
|
|
if (statement === void 0)
|
|
return to;
|
|
let statementIndex = 0;
|
|
for (; statementIndex < to.length; ++statementIndex) {
|
|
if (!isPrologueDirective2(to[statementIndex])) {
|
|
break;
|
|
}
|
|
}
|
|
to.splice(statementIndex, 0, statement);
|
|
return to;
|
|
}
|
|
function isAnyPrologueDirective(node) {
|
|
return isPrologueDirective(node) || !!(getEmitFlags(node) & 2097152 /* CustomPrologue */);
|
|
}
|
|
function insertStatementsAfterStandardPrologue(to, from) {
|
|
return insertStatementsAfterPrologue(to, from, isPrologueDirective);
|
|
}
|
|
function insertStatementsAfterCustomPrologue(to, from) {
|
|
return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective);
|
|
}
|
|
function insertStatementAfterCustomPrologue(to, statement) {
|
|
return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective);
|
|
}
|
|
function isRecognizedTripleSlashComment(text, commentPos, commentEnd) {
|
|
if (text.charCodeAt(commentPos + 1) === 47 /* slash */ && commentPos + 2 < commentEnd && text.charCodeAt(commentPos + 2) === 47 /* slash */) {
|
|
const textSubStr = text.substring(commentPos, commentEnd);
|
|
return fullTripleSlashReferencePathRegEx.test(textSubStr) || fullTripleSlashAMDReferencePathRegEx.test(textSubStr) || fullTripleSlashReferenceTypeReferenceDirectiveRegEx.test(textSubStr) || defaultLibReferenceRegEx.test(textSubStr) ? true : false;
|
|
}
|
|
return false;
|
|
}
|
|
function isPinnedComment(text, start) {
|
|
return text.charCodeAt(start + 1) === 42 /* asterisk */ && text.charCodeAt(start + 2) === 33 /* exclamation */;
|
|
}
|
|
function createCommentDirectivesMap(sourceFile, commentDirectives) {
|
|
const directivesByLine = new Map(
|
|
commentDirectives.map((commentDirective) => [
|
|
`${getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line}`,
|
|
commentDirective
|
|
])
|
|
);
|
|
const usedLines = /* @__PURE__ */ new Map();
|
|
return { getUnusedExpectations, markUsed };
|
|
function getUnusedExpectations() {
|
|
return arrayFrom(directivesByLine.entries()).filter(([line, directive]) => directive.type === 0 /* ExpectError */ && !usedLines.get(line)).map(([_, directive]) => directive);
|
|
}
|
|
function markUsed(line) {
|
|
if (!directivesByLine.has(`${line}`)) {
|
|
return false;
|
|
}
|
|
usedLines.set(`${line}`, true);
|
|
return true;
|
|
}
|
|
}
|
|
function getTokenPosOfNode(node, sourceFile, includeJsDoc) {
|
|
if (nodeIsMissing(node)) {
|
|
return node.pos;
|
|
}
|
|
if (isJSDocNode(node) || node.kind === 11 /* JsxText */) {
|
|
return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, false, true);
|
|
}
|
|
if (includeJsDoc && hasJSDocNodes(node)) {
|
|
return getTokenPosOfNode(node.jsDoc[0], sourceFile);
|
|
}
|
|
if (node.kind === 351 /* SyntaxList */ && node._children.length > 0) {
|
|
return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
|
|
}
|
|
return skipTrivia(
|
|
(sourceFile || getSourceFileOfNode(node)).text,
|
|
node.pos,
|
|
false,
|
|
false,
|
|
isInJSDoc(node)
|
|
);
|
|
}
|
|
function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia = false) {
|
|
return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia);
|
|
}
|
|
function isJSDocTypeExpressionOrChild(node) {
|
|
return !!findAncestor(node, isJSDocTypeExpression);
|
|
}
|
|
function isExportNamespaceAsDefaultDeclaration(node) {
|
|
return !!(isExportDeclaration(node) && node.exportClause && isNamespaceExport(node.exportClause) && node.exportClause.name.escapedText === "default");
|
|
}
|
|
function getTextOfNodeFromSourceText(sourceText, node, includeTrivia = false) {
|
|
if (nodeIsMissing(node)) {
|
|
return "";
|
|
}
|
|
let text = sourceText.substring(includeTrivia ? node.pos : skipTrivia(sourceText, node.pos), node.end);
|
|
if (isJSDocTypeExpressionOrChild(node)) {
|
|
text = text.split(/\r\n|\n|\r/).map((line) => trimStringStart(line.replace(/^\s*\*/, ""))).join("\n");
|
|
}
|
|
return text;
|
|
}
|
|
function getTextOfNode(node, includeTrivia = false) {
|
|
return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);
|
|
}
|
|
function getPos(range) {
|
|
return range.pos;
|
|
}
|
|
function indexOfNode(nodeArray, node) {
|
|
return binarySearch(nodeArray, node, getPos, compareValues);
|
|
}
|
|
function getEmitFlags(node) {
|
|
const emitNode = node.emitNode;
|
|
return emitNode && emitNode.flags || 0;
|
|
}
|
|
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: emptyArray,
|
|
PromiseConstructor: ["all", "race", "reject", "resolve"],
|
|
Symbol: ["for", "keyFor"],
|
|
WeakMap: ["entries", "keys", "values"],
|
|
WeakSet: ["entries", "keys", "values"],
|
|
Iterator: emptyArray,
|
|
AsyncIterator: 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: emptyArray,
|
|
SharedArrayBuffer: emptyArray,
|
|
String: ["padStart", "padEnd"],
|
|
ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"],
|
|
DateTimeFormat: ["formatToParts"]
|
|
},
|
|
es2018: {
|
|
Promise: ["finally"],
|
|
RegExpMatchArray: ["groups"],
|
|
RegExpExecArray: ["groups"],
|
|
RegExp: ["dotAll"],
|
|
Intl: ["PluralRules"],
|
|
AsyncIterable: emptyArray,
|
|
AsyncIterableIterator: emptyArray,
|
|
AsyncGenerator: emptyArray,
|
|
AsyncGeneratorFunction: emptyArray,
|
|
NumberFormat: ["formatToParts"]
|
|
},
|
|
es2019: {
|
|
Array: ["flat", "flatMap"],
|
|
ObjectConstructor: ["fromEntries"],
|
|
String: ["trimStart", "trimEnd", "trimLeft", "trimRight"],
|
|
Symbol: ["description"]
|
|
},
|
|
es2020: {
|
|
BigInt: emptyArray,
|
|
BigInt64Array: emptyArray,
|
|
BigUint64Array: 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"]
|
|
}
|
|
};
|
|
}
|
|
function getLiteralText(node, sourceFile, flags) {
|
|
var _a2;
|
|
if (sourceFile && canUseOriginalText(node, flags)) {
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node);
|
|
}
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */: {
|
|
const escapeText = flags & 2 /* JsxAttributeEscape */ ? escapeJsxAttributeString : flags & 1 /* NeverAsciiEscape */ || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? escapeString : escapeNonAsciiString;
|
|
if (node.singleQuote) {
|
|
return "'" + escapeText(node.text, 39 /* singleQuote */) + "'";
|
|
} else {
|
|
return '"' + escapeText(node.text, 34 /* doubleQuote */) + '"';
|
|
}
|
|
}
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */: {
|
|
const escapeText = flags & 1 /* NeverAsciiEscape */ || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? escapeString : escapeNonAsciiString;
|
|
const rawText = (_a2 = node.rawText) != null ? _a2 : escapeTemplateSubstitution(escapeText(node.text, 96 /* backtick */));
|
|
switch (node.kind) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return "`" + rawText + "`";
|
|
case 15 /* TemplateHead */:
|
|
return "`" + rawText + "${";
|
|
case 16 /* TemplateMiddle */:
|
|
return "}" + rawText + "${";
|
|
case 17 /* TemplateTail */:
|
|
return "}" + rawText + "`";
|
|
}
|
|
break;
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return node.text;
|
|
case 13 /* RegularExpressionLiteral */:
|
|
if (flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
|
|
return node.text + (node.text.charCodeAt(node.text.length - 1) === 92 /* backslash */ ? " /" : "/");
|
|
}
|
|
return node.text;
|
|
}
|
|
return Debug.fail(`Literal kind '${node.kind}' not accounted for.`);
|
|
}
|
|
function canUseOriginalText(node, flags) {
|
|
if (nodeIsSynthesized(node) || !node.parent || flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
|
|
return false;
|
|
}
|
|
if (isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) {
|
|
return !!(flags & 8 /* AllowNumericSeparator */);
|
|
}
|
|
return !isBigIntLiteral(node);
|
|
}
|
|
function makeIdentifierFromModuleName(moduleName) {
|
|
return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");
|
|
}
|
|
function isBlockOrCatchScoped(declaration) {
|
|
return (getCombinedNodeFlags(declaration) & 3 /* BlockScoped */) !== 0 || isCatchClauseVariableDeclarationOrBindingElement(declaration);
|
|
}
|
|
function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
|
|
const node = getRootDeclaration(declaration);
|
|
return node.kind === 257 /* VariableDeclaration */ && node.parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isAmbientModule(node) {
|
|
return isModuleDeclaration(node) && (node.name.kind === 10 /* StringLiteral */ || isGlobalScopeAugmentation(node));
|
|
}
|
|
function isModuleWithStringLiteralName(node) {
|
|
return isModuleDeclaration(node) && node.name.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isNonGlobalAmbientModule(node) {
|
|
return isModuleDeclaration(node) && isStringLiteral(node.name);
|
|
}
|
|
function isEffectiveModuleDeclaration(node) {
|
|
return isModuleDeclaration(node) || isIdentifier(node);
|
|
}
|
|
function isShorthandAmbientModuleSymbol(moduleSymbol) {
|
|
return isShorthandAmbientModule(moduleSymbol.valueDeclaration);
|
|
}
|
|
function isShorthandAmbientModule(node) {
|
|
return !!node && node.kind === 264 /* ModuleDeclaration */ && !node.body;
|
|
}
|
|
function isBlockScopedContainerTopLevel(node) {
|
|
return node.kind === 308 /* SourceFile */ || node.kind === 264 /* ModuleDeclaration */ || isFunctionLikeOrClassStaticBlockDeclaration(node);
|
|
}
|
|
function isGlobalScopeAugmentation(module2) {
|
|
return !!(module2.flags & 1024 /* GlobalAugmentation */);
|
|
}
|
|
function isExternalModuleAugmentation(node) {
|
|
return isAmbientModule(node) && isModuleAugmentationExternal(node);
|
|
}
|
|
function isModuleAugmentationExternal(node) {
|
|
switch (node.parent.kind) {
|
|
case 308 /* SourceFile */:
|
|
return isExternalModule(node.parent);
|
|
case 265 /* ModuleBlock */:
|
|
return isAmbientModule(node.parent.parent) && isSourceFile(node.parent.parent.parent) && !isExternalModule(node.parent.parent.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function getNonAugmentationDeclaration(symbol) {
|
|
var _a2;
|
|
return (_a2 = symbol.declarations) == null ? void 0 : _a2.find((d) => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));
|
|
}
|
|
function isCommonJSContainingModuleKind(kind) {
|
|
return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
|
|
}
|
|
function isEffectiveExternalModule(node, compilerOptions) {
|
|
return isExternalModule(node) || compilerOptions.isolatedModules || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
|
|
}
|
|
function isEffectiveStrictModeSourceFile(node, compilerOptions) {
|
|
switch (node.scriptKind) {
|
|
case 1 /* JS */:
|
|
case 3 /* TS */:
|
|
case 2 /* JSX */:
|
|
case 4 /* TSX */:
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (node.isDeclarationFile) {
|
|
return false;
|
|
}
|
|
if (getStrictOptionValue(compilerOptions, "alwaysStrict")) {
|
|
return true;
|
|
}
|
|
if (startsWithUseStrict(node.statements)) {
|
|
return true;
|
|
}
|
|
if (isExternalModule(node) || compilerOptions.isolatedModules) {
|
|
if (getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
|
|
return true;
|
|
}
|
|
return !compilerOptions.noImplicitUseStrict;
|
|
}
|
|
return false;
|
|
}
|
|
function isBlockScope(node, parentNode) {
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 266 /* CaseBlock */:
|
|
case 295 /* CatchClause */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return true;
|
|
case 238 /* Block */:
|
|
return !isFunctionLikeOrClassStaticBlockDeclaration(parentNode);
|
|
}
|
|
return false;
|
|
}
|
|
function isAnyImportSyntax(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isLateVisibilityPaintedStatement(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function hasPossibleExternalModuleReference(node) {
|
|
return isAnyImportOrReExport(node) || isModuleDeclaration(node) || isImportTypeNode(node) || isImportCall(node);
|
|
}
|
|
function isAnyImportOrReExport(node) {
|
|
return isAnyImportSyntax(node) || isExportDeclaration(node);
|
|
}
|
|
function getEnclosingBlockScopeContainer(node) {
|
|
return findAncestor(node.parent, (current) => isBlockScope(current, current.parent));
|
|
}
|
|
function forEachEnclosingBlockScopeContainer(node, cb) {
|
|
let container = getEnclosingBlockScopeContainer(node);
|
|
while (container) {
|
|
cb(container);
|
|
container = getEnclosingBlockScopeContainer(container);
|
|
}
|
|
}
|
|
function declarationNameToString(name) {
|
|
return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
|
|
}
|
|
function getNameFromIndexInfo(info) {
|
|
return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : void 0;
|
|
}
|
|
function isComputedNonLiteralName(name) {
|
|
return name.kind === 164 /* ComputedPropertyName */ && !isStringOrNumericLiteralLike(name.expression);
|
|
}
|
|
function tryGetTextOfPropertyName(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return name.autoGenerateFlags ? void 0 : name.escapedText;
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return escapeLeadingUnderscores(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
if (isStringOrNumericLiteralLike(name.expression))
|
|
return escapeLeadingUnderscores(name.expression.text);
|
|
return void 0;
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function getTextOfPropertyName(name) {
|
|
return Debug.checkDefined(tryGetTextOfPropertyName(name));
|
|
}
|
|
function entityNameToString(name) {
|
|
switch (name.kind) {
|
|
case 108 /* ThisKeyword */:
|
|
return "this";
|
|
case 80 /* PrivateIdentifier */:
|
|
case 79 /* Identifier */:
|
|
return getFullWidth(name) === 0 ? idText(name) : getTextOfNode(name);
|
|
case 163 /* QualifiedName */:
|
|
return entityNameToString(name.left) + "." + entityNameToString(name.right);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (isIdentifier(name.name) || isPrivateIdentifier(name.name)) {
|
|
return entityNameToString(name.expression) + "." + entityNameToString(name.name);
|
|
} else {
|
|
return Debug.assertNever(name.name);
|
|
}
|
|
case 314 /* JSDocMemberName */:
|
|
return entityNameToString(name.left) + entityNameToString(name.right);
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
|
|
const start = skipTrivia(sourceFile.text, nodes.pos);
|
|
return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
|
|
const span = getErrorSpanForNode(sourceFile, node);
|
|
return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const span = getErrorSpanForNode(sourceFile, node);
|
|
return createFileDiagnosticFromMessageChain(sourceFile, span.start, span.length, messageChain, relatedInformation);
|
|
}
|
|
function assertDiagnosticLocation(file, start, length2) {
|
|
Debug.assertGreaterThanOrEqual(start, 0);
|
|
Debug.assertGreaterThanOrEqual(length2, 0);
|
|
if (file) {
|
|
Debug.assertLessThanOrEqual(start, file.text.length);
|
|
Debug.assertLessThanOrEqual(start + length2, file.text.length);
|
|
}
|
|
}
|
|
function createFileDiagnosticFromMessageChain(file, start, length2, messageChain, relatedInformation) {
|
|
assertDiagnosticLocation(file, start, length2);
|
|
return {
|
|
file,
|
|
start,
|
|
length: length2,
|
|
code: messageChain.code,
|
|
category: messageChain.category,
|
|
messageText: messageChain.next ? messageChain : messageChain.messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
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
|
|
};
|
|
}
|
|
function createDiagnosticMessageChainFromDiagnostic(diagnostic) {
|
|
return typeof diagnostic.messageText === "string" ? {
|
|
code: diagnostic.code,
|
|
category: diagnostic.category,
|
|
messageText: diagnostic.messageText,
|
|
next: diagnostic.next
|
|
} : diagnostic.messageText;
|
|
}
|
|
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
|
|
};
|
|
}
|
|
function getSpanOfTokenAtPosition(sourceFile, pos) {
|
|
const scanner = createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, void 0, pos);
|
|
scanner.scan();
|
|
const start = scanner.getTokenPos();
|
|
return createTextSpanFromBounds(start, scanner.getTextPos());
|
|
}
|
|
function getErrorSpanForArrowFunction(sourceFile, node) {
|
|
const pos = skipTrivia(sourceFile.text, node.pos);
|
|
if (node.body && node.body.kind === 238 /* Block */) {
|
|
const { line: startLine } = getLineAndCharacterOfPosition(sourceFile, node.body.pos);
|
|
const { line: endLine } = getLineAndCharacterOfPosition(sourceFile, node.body.end);
|
|
if (startLine < endLine) {
|
|
return createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1);
|
|
}
|
|
}
|
|
return createTextSpanFromBounds(pos, node.end);
|
|
}
|
|
function getErrorSpanForNode(sourceFile, node) {
|
|
let errorNode = node;
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
const pos2 = skipTrivia(sourceFile.text, 0, false);
|
|
if (pos2 === sourceFile.text.length) {
|
|
return createTextSpan(0, 0);
|
|
}
|
|
return getSpanOfTokenAtPosition(sourceFile, pos2);
|
|
case 257 /* VariableDeclaration */:
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 271 /* NamespaceImport */:
|
|
errorNode = node.name;
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
return getErrorSpanForArrowFunction(sourceFile, node);
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
const start = skipTrivia(sourceFile.text, node.pos);
|
|
const end = node.statements.length > 0 ? node.statements[0].pos : node.end;
|
|
return createTextSpanFromBounds(start, end);
|
|
}
|
|
if (errorNode === void 0) {
|
|
return getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
}
|
|
Debug.assert(!isJSDoc(errorNode));
|
|
const isMissing = nodeIsMissing(errorNode);
|
|
const pos = isMissing || isJsxText(node) ? errorNode.pos : skipTrivia(sourceFile.text, errorNode.pos);
|
|
if (isMissing) {
|
|
Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
} else {
|
|
Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
}
|
|
return createTextSpanFromBounds(pos, errorNode.end);
|
|
}
|
|
function isExternalOrCommonJsModule(file) {
|
|
return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== void 0;
|
|
}
|
|
function isJsonSourceFile(file) {
|
|
return file.scriptKind === 6 /* JSON */;
|
|
}
|
|
function isEnumConst(node) {
|
|
return !!(getCombinedModifierFlags(node) & 2048 /* Const */);
|
|
}
|
|
function isDeclarationReadonly(declaration) {
|
|
return !!(getCombinedModifierFlags(declaration) & 64 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
|
|
}
|
|
function isVarConst(node) {
|
|
return !!(getCombinedNodeFlags(node) & 2 /* Const */);
|
|
}
|
|
function isLet(node) {
|
|
return !!(getCombinedNodeFlags(node) & 1 /* Let */);
|
|
}
|
|
function isSuperCall(n) {
|
|
return n.kind === 210 /* CallExpression */ && n.expression.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isImportCall(n) {
|
|
return n.kind === 210 /* CallExpression */ && n.expression.kind === 100 /* ImportKeyword */;
|
|
}
|
|
function isImportMeta(n) {
|
|
return isMetaProperty(n) && n.keywordToken === 100 /* ImportKeyword */ && n.name.escapedText === "meta";
|
|
}
|
|
function isLiteralImportTypeNode(n) {
|
|
return isImportTypeNode(n) && isLiteralTypeNode(n.argument) && isStringLiteral(n.argument.literal);
|
|
}
|
|
function isPrologueDirective(node) {
|
|
return node.kind === 241 /* ExpressionStatement */ && node.expression.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isCustomPrologue(node) {
|
|
return !!(getEmitFlags(node) & 2097152 /* CustomPrologue */);
|
|
}
|
|
function isHoistedFunction(node) {
|
|
return isCustomPrologue(node) && isFunctionDeclaration(node);
|
|
}
|
|
function isHoistedVariable(node) {
|
|
return isIdentifier(node.name) && !node.initializer;
|
|
}
|
|
function isHoistedVariableStatement(node) {
|
|
return isCustomPrologue(node) && isVariableStatement(node) && every(node.declarationList.declarations, isHoistedVariable);
|
|
}
|
|
function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
|
|
return node.kind !== 11 /* JsxText */ ? getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : void 0;
|
|
}
|
|
function getJSDocCommentRanges(node, text) {
|
|
const commentRanges = node.kind === 166 /* Parameter */ || node.kind === 165 /* TypeParameter */ || node.kind === 215 /* FunctionExpression */ || node.kind === 216 /* ArrowFunction */ || node.kind === 214 /* ParenthesizedExpression */ || node.kind === 257 /* VariableDeclaration */ || node.kind === 278 /* ExportSpecifier */ ? concatenate(getTrailingCommentRanges(text, node.pos), getLeadingCommentRanges(text, node.pos)) : getLeadingCommentRanges(text, node.pos);
|
|
return filter(commentRanges, (comment) => text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
|
|
}
|
|
var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)(('[^']*')|("[^"]*"))\s*\/>/;
|
|
function isPartOfTypeNode(node) {
|
|
if (179 /* FirstTypeNode */ <= node.kind && node.kind <= 202 /* LastTypeNode */) {
|
|
return true;
|
|
}
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
return true;
|
|
case 114 /* VoidKeyword */:
|
|
return node.parent.kind !== 219 /* VoidExpression */;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
|
|
case 165 /* TypeParameter */:
|
|
return node.parent.kind === 197 /* MappedType */ || node.parent.kind === 192 /* InferType */;
|
|
case 79 /* Identifier */:
|
|
if (node.parent.kind === 163 /* QualifiedName */ && node.parent.right === node) {
|
|
node = node.parent;
|
|
} else if (node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.name === node) {
|
|
node = node.parent;
|
|
}
|
|
Debug.assert(
|
|
node.kind === 79 /* Identifier */ || node.kind === 163 /* QualifiedName */ || node.kind === 208 /* PropertyAccessExpression */,
|
|
"'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."
|
|
);
|
|
case 163 /* QualifiedName */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 108 /* ThisKeyword */: {
|
|
const { parent } = node;
|
|
if (parent.kind === 183 /* TypeQuery */) {
|
|
return false;
|
|
}
|
|
if (parent.kind === 202 /* ImportType */) {
|
|
return !parent.isTypeOf;
|
|
}
|
|
if (179 /* FirstTypeNode */ <= parent.kind && parent.kind <= 202 /* LastTypeNode */) {
|
|
return true;
|
|
}
|
|
switch (parent.kind) {
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
|
|
case 165 /* TypeParameter */:
|
|
return node === parent.constraint;
|
|
case 347 /* JSDocTemplateTag */:
|
|
return node === parent.constraint;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 166 /* Parameter */:
|
|
case 257 /* VariableDeclaration */:
|
|
return node === parent.type;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return node === parent.type;
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return node === parent.type;
|
|
case 213 /* TypeAssertionExpression */:
|
|
return node === parent.type;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return contains(parent.typeArguments, node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isChildOfNodeWithKind(node, kind) {
|
|
while (node) {
|
|
if (node.kind === kind) {
|
|
return true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function forEachReturnStatement(body, visitor) {
|
|
return traverse(body);
|
|
function traverse(node) {
|
|
switch (node.kind) {
|
|
case 250 /* ReturnStatement */:
|
|
return visitor(node);
|
|
case 266 /* CaseBlock */:
|
|
case 238 /* Block */:
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 253 /* LabeledStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 295 /* CatchClause */:
|
|
return forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
function forEachYieldExpression(body, visitor) {
|
|
return traverse(body);
|
|
function traverse(node) {
|
|
switch (node.kind) {
|
|
case 226 /* YieldExpression */:
|
|
visitor(node);
|
|
const operand = node.expression;
|
|
if (operand) {
|
|
traverse(operand);
|
|
}
|
|
return;
|
|
case 263 /* EnumDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return;
|
|
default:
|
|
if (isFunctionLike(node)) {
|
|
if (node.name && node.name.kind === 164 /* ComputedPropertyName */) {
|
|
traverse(node.name.expression);
|
|
return;
|
|
}
|
|
} else if (!isPartOfTypeNode(node)) {
|
|
forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getRestParameterElementType(node) {
|
|
if (node && node.kind === 185 /* ArrayType */) {
|
|
return node.elementType;
|
|
} else if (node && node.kind === 180 /* TypeReference */) {
|
|
return singleOrUndefined(node.typeArguments);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
function getMembersOfDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 184 /* TypeLiteral */:
|
|
return node.members;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return node.properties;
|
|
}
|
|
}
|
|
function isVariableLike(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 302 /* EnumMember */:
|
|
case 166 /* Parameter */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 257 /* VariableDeclaration */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isVariableLikeOrAccessor(node) {
|
|
return isVariableLike(node) || isAccessor(node);
|
|
}
|
|
function isVariableDeclarationInVariableStatement(node) {
|
|
return node.parent.kind === 258 /* VariableDeclarationList */ && node.parent.parent.kind === 240 /* VariableStatement */;
|
|
}
|
|
function isCommonJsExportedExpression(node) {
|
|
if (!isInJSFile(node))
|
|
return false;
|
|
return isObjectLiteralExpression(node.parent) && isBinaryExpression(node.parent.parent) && getAssignmentDeclarationKind(node.parent.parent) === 2 /* ModuleExports */ || isCommonJsExportPropertyAssignment(node.parent);
|
|
}
|
|
function isCommonJsExportPropertyAssignment(node) {
|
|
if (!isInJSFile(node))
|
|
return false;
|
|
return isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 1 /* ExportsProperty */;
|
|
}
|
|
function isValidESSymbolDeclaration(node) {
|
|
return (isVariableDeclaration(node) ? isVarConst(node) && isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) : isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) : isPropertySignature(node) && hasEffectiveReadonlyModifier(node)) || isCommonJsExportPropertyAssignment(node);
|
|
}
|
|
function introducesArgumentsExoticObject(node) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function unwrapInnermostStatementOfLabel(node, beforeUnwrapLabelCallback) {
|
|
while (true) {
|
|
if (beforeUnwrapLabelCallback) {
|
|
beforeUnwrapLabelCallback(node);
|
|
}
|
|
if (node.statement.kind !== 253 /* LabeledStatement */) {
|
|
return node.statement;
|
|
}
|
|
node = node.statement;
|
|
}
|
|
}
|
|
function isFunctionBlock(node) {
|
|
return node && node.kind === 238 /* Block */ && isFunctionLike(node.parent);
|
|
}
|
|
function isObjectLiteralMethod(node) {
|
|
return node && node.kind === 171 /* MethodDeclaration */ && node.parent.kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
|
|
return (node.kind === 171 /* MethodDeclaration */ || node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */) && (node.parent.kind === 207 /* ObjectLiteralExpression */ || node.parent.kind === 228 /* ClassExpression */);
|
|
}
|
|
function isIdentifierTypePredicate(predicate) {
|
|
return predicate && predicate.kind === 1 /* Identifier */;
|
|
}
|
|
function getPropertyAssignment(objectLiteral, key, key2) {
|
|
return objectLiteral.properties.filter((property) => {
|
|
if (property.kind === 299 /* PropertyAssignment */) {
|
|
const propName = tryGetTextOfPropertyName(property.name);
|
|
return key === propName || !!key2 && key2 === propName;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
|
|
return firstDefined(getPropertyAssignment(objectLiteral, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
|
|
}
|
|
function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
|
|
if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
|
|
const expression = tsConfigSourceFile.statements[0].expression;
|
|
return tryCast(expression, isObjectLiteralExpression);
|
|
}
|
|
}
|
|
function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
|
|
return firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
|
|
}
|
|
function getTsConfigPropArray(tsConfigSourceFile, propKey) {
|
|
const jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile);
|
|
return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : emptyArray;
|
|
}
|
|
function getContainingFunction(node) {
|
|
return findAncestor(node.parent, isFunctionLike);
|
|
}
|
|
function getContainingClass(node) {
|
|
return findAncestor(node.parent, isClassLike);
|
|
}
|
|
function getContainingFunctionOrClassStaticBlock(node) {
|
|
return findAncestor(node.parent, isFunctionLikeOrClassStaticBlockDeclaration);
|
|
}
|
|
function getThisContainer(node, includeArrowFunctions) {
|
|
Debug.assert(node.kind !== 308 /* SourceFile */);
|
|
while (true) {
|
|
node = node.parent;
|
|
if (!node) {
|
|
return Debug.fail();
|
|
}
|
|
switch (node.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
if (isClassLike(node.parent.parent)) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
break;
|
|
case 167 /* Decorator */:
|
|
if (node.parent.kind === 166 /* Parameter */ && isClassElement(node.parent.parent)) {
|
|
node = node.parent.parent;
|
|
} else if (isClassElement(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
if (!includeArrowFunctions) {
|
|
continue;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 308 /* SourceFile */:
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function isThisContainerOrFunctionBlock(node) {
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
case 238 /* Block */:
|
|
switch (node.parent.kind) {
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInTopLevelContext(node) {
|
|
if (isIdentifier(node) && (isClassDeclaration(node.parent) || isFunctionDeclaration(node.parent)) && node.parent.name === node) {
|
|
node = node.parent;
|
|
}
|
|
const container = getThisContainer(node, true);
|
|
return isSourceFile(container);
|
|
}
|
|
function getNewTargetContainer(node) {
|
|
const container = getThisContainer(node, false);
|
|
if (container) {
|
|
switch (container.kind) {
|
|
case 173 /* Constructor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return container;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSuperContainer(node, stopOnFunctions) {
|
|
while (true) {
|
|
node = node.parent;
|
|
if (!node) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
node = node.parent;
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (!stopOnFunctions) {
|
|
continue;
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return node;
|
|
case 167 /* Decorator */:
|
|
if (node.parent.kind === 166 /* Parameter */ && isClassElement(node.parent.parent)) {
|
|
node = node.parent.parent;
|
|
} else if (isClassElement(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function getImmediatelyInvokedFunctionExpression(func) {
|
|
if (func.kind === 215 /* FunctionExpression */ || func.kind === 216 /* ArrowFunction */) {
|
|
let prev = func;
|
|
let parent = func.parent;
|
|
while (parent.kind === 214 /* ParenthesizedExpression */) {
|
|
prev = parent;
|
|
parent = parent.parent;
|
|
}
|
|
if (parent.kind === 210 /* CallExpression */ && parent.expression === prev) {
|
|
return parent;
|
|
}
|
|
}
|
|
}
|
|
function isSuperProperty(node) {
|
|
const kind = node.kind;
|
|
return (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */) && node.expression.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isThisProperty(node) {
|
|
const kind = node.kind;
|
|
return (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */) && node.expression.kind === 108 /* ThisKeyword */;
|
|
}
|
|
function isThisInitializedDeclaration(node) {
|
|
var _a2;
|
|
return !!node && isVariableDeclaration(node) && ((_a2 = node.initializer) == null ? void 0 : _a2.kind) === 108 /* ThisKeyword */;
|
|
}
|
|
function isThisInitializedObjectBindingExpression(node) {
|
|
return !!node && (isShorthandPropertyAssignment(node) || isPropertyAssignment(node)) && isBinaryExpression(node.parent.parent) && node.parent.parent.operatorToken.kind === 63 /* EqualsToken */ && node.parent.parent.right.kind === 108 /* ThisKeyword */;
|
|
}
|
|
function getEntityNameFromTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isEntityNameExpression(node.expression) ? node.expression : void 0;
|
|
case 79 /* Identifier */:
|
|
case 163 /* QualifiedName */:
|
|
return node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getInvokedExpression(node) {
|
|
switch (node.kind) {
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return node.tag;
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return node.tagName;
|
|
default:
|
|
return node.expression;
|
|
}
|
|
}
|
|
function nodeCanBeDecorated(node, parent, grandparent) {
|
|
if (isNamedDeclaration(node) && isPrivateIdentifier(node.name)) {
|
|
return false;
|
|
}
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
return true;
|
|
case 169 /* PropertyDeclaration */:
|
|
return parent.kind === 260 /* ClassDeclaration */;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
return node.body !== void 0 && parent.kind === 260 /* ClassDeclaration */;
|
|
case 166 /* Parameter */:
|
|
return parent.body !== void 0 && (parent.kind === 173 /* Constructor */ || parent.kind === 171 /* MethodDeclaration */ || parent.kind === 175 /* SetAccessor */) && grandparent.kind === 260 /* ClassDeclaration */;
|
|
}
|
|
return false;
|
|
}
|
|
function nodeIsDecorated(node, parent, grandparent) {
|
|
return hasDecorators(node) && nodeCanBeDecorated(node, parent, grandparent);
|
|
}
|
|
function nodeOrChildIsDecorated(node, parent, grandparent) {
|
|
return nodeIsDecorated(node, parent, grandparent) || childIsDecorated(node, parent);
|
|
}
|
|
function childIsDecorated(node, parent) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
return some(node.members, (m) => nodeOrChildIsDecorated(m, node, parent));
|
|
case 171 /* MethodDeclaration */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
return some(node.parameters, (p) => nodeIsDecorated(p, node, parent));
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function classOrConstructorParameterIsDecorated(node) {
|
|
if (nodeIsDecorated(node))
|
|
return true;
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
return !!constructor && childIsDecorated(constructor, node);
|
|
}
|
|
function isJSXTagName(node) {
|
|
const { parent } = node;
|
|
if (parent.kind === 283 /* JsxOpeningElement */ || parent.kind === 282 /* JsxSelfClosingElement */ || parent.kind === 284 /* JsxClosingElement */) {
|
|
return parent.tagName === node;
|
|
}
|
|
return false;
|
|
}
|
|
function isExpressionNode(node) {
|
|
switch (node.kind) {
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 223 /* BinaryExpression */:
|
|
case 224 /* ConditionalExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 225 /* TemplateExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
case 226 /* YieldExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 233 /* MetaProperty */:
|
|
return true;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return !isHeritageClause(node.parent);
|
|
case 163 /* QualifiedName */:
|
|
while (node.parent.kind === 163 /* QualifiedName */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node);
|
|
case 314 /* JSDocMemberName */:
|
|
while (isJSDocMemberName(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 101 /* InKeyword */;
|
|
case 79 /* Identifier */:
|
|
if (node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node)) {
|
|
return true;
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 108 /* ThisKeyword */:
|
|
return isInExpressionContext(node);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInExpressionContext(node) {
|
|
const { parent } = node;
|
|
switch (parent.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 302 /* EnumMember */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 205 /* BindingElement */:
|
|
return parent.initializer === node;
|
|
case 241 /* ExpressionStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 250 /* ReturnStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 292 /* CaseClause */:
|
|
case 254 /* ThrowStatement */:
|
|
return parent.expression === node;
|
|
case 245 /* ForStatement */:
|
|
const forStatement = parent;
|
|
return forStatement.initializer === node && forStatement.initializer.kind !== 258 /* VariableDeclarationList */ || forStatement.condition === node || forStatement.incrementor === node;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
const forInStatement = parent;
|
|
return forInStatement.initializer === node && forInStatement.initializer.kind !== 258 /* VariableDeclarationList */ || forInStatement.expression === node;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return node === parent.expression;
|
|
case 236 /* TemplateSpan */:
|
|
return node === parent.expression;
|
|
case 164 /* ComputedPropertyName */:
|
|
return node === parent.expression;
|
|
case 167 /* Decorator */:
|
|
case 291 /* JsxExpression */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
case 301 /* SpreadAssignment */:
|
|
return true;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return parent.expression === node && !isPartOfTypeNode(parent);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return parent.objectAssignmentInitializer === node;
|
|
case 235 /* SatisfiesExpression */:
|
|
return node === parent.expression;
|
|
default:
|
|
return isExpressionNode(parent);
|
|
}
|
|
}
|
|
function isPartOfTypeQuery(node) {
|
|
while (node.kind === 163 /* QualifiedName */ || node.kind === 79 /* Identifier */) {
|
|
node = node.parent;
|
|
}
|
|
return node.kind === 183 /* TypeQuery */;
|
|
}
|
|
function isNamespaceReexportDeclaration(node) {
|
|
return isNamespaceExport(node) && !!node.parent.moduleSpecifier;
|
|
}
|
|
function isExternalModuleImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 280 /* ExternalModuleReference */;
|
|
}
|
|
function getExternalModuleImportEqualsDeclarationExpression(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node));
|
|
return node.moduleReference.expression;
|
|
}
|
|
function getExternalModuleRequireArgument(node) {
|
|
return isVariableDeclarationInitializedToBareOrAccessedRequire(node) && getLeftmostAccessExpression(node.initializer).arguments[0];
|
|
}
|
|
function isInternalModuleImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 280 /* ExternalModuleReference */;
|
|
}
|
|
function isSourceFileJS(file) {
|
|
return isInJSFile(file);
|
|
}
|
|
function isInJSFile(node) {
|
|
return !!node && !!(node.flags & 262144 /* JavaScriptFile */);
|
|
}
|
|
function isInJsonFile(node) {
|
|
return !!node && !!(node.flags & 67108864 /* JsonFile */);
|
|
}
|
|
function isSourceFileNotJson(file) {
|
|
return !isJsonSourceFile(file);
|
|
}
|
|
function isInJSDoc(node) {
|
|
return !!node && !!(node.flags & 8388608 /* JSDoc */);
|
|
}
|
|
function isJSDocIndexSignature(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && node.typeArguments && node.typeArguments.length === 2 && (node.typeArguments[0].kind === 152 /* StringKeyword */ || node.typeArguments[0].kind === 148 /* NumberKeyword */);
|
|
}
|
|
function isRequireCall(callExpression, requireStringLiteralLikeArgument) {
|
|
if (callExpression.kind !== 210 /* CallExpression */) {
|
|
return false;
|
|
}
|
|
const { expression, arguments: args } = callExpression;
|
|
if (expression.kind !== 79 /* Identifier */ || expression.escapedText !== "require") {
|
|
return false;
|
|
}
|
|
if (args.length !== 1) {
|
|
return false;
|
|
}
|
|
const arg = args[0];
|
|
return !requireStringLiteralLikeArgument || isStringLiteralLike(arg);
|
|
}
|
|
function isVariableDeclarationInitializedToBareOrAccessedRequire(node) {
|
|
return isVariableDeclarationInitializedWithRequireHelper(node, true);
|
|
}
|
|
function isVariableDeclarationInitializedWithRequireHelper(node, allowAccessedRequire) {
|
|
return isVariableDeclaration(node) && !!node.initializer && isRequireCall(allowAccessedRequire ? getLeftmostAccessExpression(node.initializer) : node.initializer, true);
|
|
}
|
|
function isSingleOrDoubleQuote(charCode) {
|
|
return charCode === 39 /* singleQuote */ || charCode === 34 /* doubleQuote */;
|
|
}
|
|
function isStringDoubleQuoted(str, sourceFile) {
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34 /* doubleQuote */;
|
|
}
|
|
function isAssignmentDeclaration(decl) {
|
|
return isBinaryExpression(decl) || isAccessExpression(decl) || isIdentifier(decl) || isCallExpression(decl);
|
|
}
|
|
function getEffectiveInitializer(node) {
|
|
if (isInJSFile(node) && node.initializer && isBinaryExpression(node.initializer) && (node.initializer.operatorToken.kind === 56 /* BarBarToken */ || node.initializer.operatorToken.kind === 60 /* QuestionQuestionToken */) && node.name && isEntityNameExpression(node.name) && isSameEntityName(node.name, node.initializer.left)) {
|
|
return node.initializer.right;
|
|
}
|
|
return node.initializer;
|
|
}
|
|
function getDeclaredExpandoInitializer(node) {
|
|
const init = getEffectiveInitializer(node);
|
|
return init && getExpandoInitializer(init, isPrototypeAccess(node.name));
|
|
}
|
|
function hasExpandoValueProperty(node, isPrototypeAssignment) {
|
|
return forEach(node.properties, (p) => isPropertyAssignment(p) && isIdentifier(p.name) && p.name.escapedText === "value" && p.initializer && getExpandoInitializer(p.initializer, isPrototypeAssignment));
|
|
}
|
|
function getAssignedExpandoInitializer(node) {
|
|
if (node && node.parent && isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const isPrototypeAssignment = isPrototypeAccess(node.parent.left);
|
|
return getExpandoInitializer(node.parent.right, isPrototypeAssignment) || getDefaultedExpandoInitializer(node.parent.left, node.parent.right, isPrototypeAssignment);
|
|
}
|
|
if (node && isCallExpression(node) && isBindableObjectDefinePropertyCall(node)) {
|
|
const result = hasExpandoValueProperty(node.arguments[2], node.arguments[1].text === "prototype");
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function getExpandoInitializer(initializer, isPrototypeAssignment) {
|
|
if (isCallExpression(initializer)) {
|
|
const e = skipParentheses(initializer.expression);
|
|
return e.kind === 215 /* FunctionExpression */ || e.kind === 216 /* ArrowFunction */ ? initializer : void 0;
|
|
}
|
|
if (initializer.kind === 215 /* FunctionExpression */ || initializer.kind === 228 /* ClassExpression */ || initializer.kind === 216 /* ArrowFunction */) {
|
|
return initializer;
|
|
}
|
|
if (isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) {
|
|
return initializer;
|
|
}
|
|
}
|
|
function getDefaultedExpandoInitializer(name, initializer, isPrototypeAssignment) {
|
|
const e = isBinaryExpression(initializer) && (initializer.operatorToken.kind === 56 /* BarBarToken */ || initializer.operatorToken.kind === 60 /* QuestionQuestionToken */) && getExpandoInitializer(initializer.right, isPrototypeAssignment);
|
|
if (e && isSameEntityName(name, initializer.left)) {
|
|
return e;
|
|
}
|
|
}
|
|
function isDefaultedExpandoInitializer(node) {
|
|
const name = isVariableDeclaration(node.parent) ? node.parent.name : isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* EqualsToken */ ? node.parent.left : void 0;
|
|
return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left);
|
|
}
|
|
function getNameOfExpando(node) {
|
|
if (isBinaryExpression(node.parent)) {
|
|
const parent = (node.parent.operatorToken.kind === 56 /* BarBarToken */ || node.parent.operatorToken.kind === 60 /* QuestionQuestionToken */) && isBinaryExpression(node.parent.parent) ? node.parent.parent : node.parent;
|
|
if (parent.operatorToken.kind === 63 /* EqualsToken */ && isIdentifier(parent.left)) {
|
|
return parent.left;
|
|
}
|
|
} else if (isVariableDeclaration(node.parent)) {
|
|
return node.parent.name;
|
|
}
|
|
}
|
|
function isSameEntityName(name, initializer) {
|
|
if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) {
|
|
return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(initializer);
|
|
}
|
|
if (isMemberName(name) && isLiteralLikeAccess(initializer) && (initializer.expression.kind === 108 /* ThisKeyword */ || 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;
|
|
}
|
|
function getRightMostAssignedExpression(node) {
|
|
while (isAssignmentExpression(node, true)) {
|
|
node = node.right;
|
|
}
|
|
return node;
|
|
}
|
|
function isExportsIdentifier(node) {
|
|
return isIdentifier(node) && node.escapedText === "exports";
|
|
}
|
|
function isModuleIdentifier(node) {
|
|
return isIdentifier(node) && node.escapedText === "module";
|
|
}
|
|
function isModuleExportsAccessExpression(node) {
|
|
return (isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node)) && isModuleIdentifier(node.expression) && getElementOrPropertyAccessName(node) === "exports";
|
|
}
|
|
function getAssignmentDeclarationKind(expr) {
|
|
const special = getAssignmentDeclarationKindWorker(expr);
|
|
return special === 5 /* Property */ || isInJSFile(expr) ? special : 0 /* None */;
|
|
}
|
|
function isBindableObjectDefinePropertyCall(expr) {
|
|
return length(expr.arguments) === 3 && isPropertyAccessExpression(expr.expression) && isIdentifier(expr.expression.expression) && idText(expr.expression.expression) === "Object" && idText(expr.expression.name) === "defineProperty" && isStringOrNumericLiteralLike(expr.arguments[1]) && isBindableStaticNameExpression(expr.arguments[0], true);
|
|
}
|
|
function isLiteralLikeAccess(node) {
|
|
return isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node);
|
|
}
|
|
function isLiteralLikeElementAccess(node) {
|
|
return isElementAccessExpression(node) && isStringOrNumericLiteralLike(node.argumentExpression);
|
|
}
|
|
function isBindableStaticAccessExpression(node, excludeThisKeyword) {
|
|
return isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 108 /* ThisKeyword */ || isIdentifier(node.name) && isBindableStaticNameExpression(node.expression, true)) || isBindableStaticElementAccessExpression(node, excludeThisKeyword);
|
|
}
|
|
function isBindableStaticElementAccessExpression(node, excludeThisKeyword) {
|
|
return isLiteralLikeElementAccess(node) && (!excludeThisKeyword && node.expression.kind === 108 /* ThisKeyword */ || isEntityNameExpression(node.expression) || isBindableStaticAccessExpression(node.expression, true));
|
|
}
|
|
function isBindableStaticNameExpression(node, excludeThisKeyword) {
|
|
return isEntityNameExpression(node) || isBindableStaticAccessExpression(node, excludeThisKeyword);
|
|
}
|
|
function getNameOrArgument(expr) {
|
|
if (isPropertyAccessExpression(expr)) {
|
|
return expr.name;
|
|
}
|
|
return expr.argumentExpression;
|
|
}
|
|
function getAssignmentDeclarationKindWorker(expr) {
|
|
if (isCallExpression(expr)) {
|
|
if (!isBindableObjectDefinePropertyCall(expr)) {
|
|
return 0 /* None */;
|
|
}
|
|
const entityName = expr.arguments[0];
|
|
if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) {
|
|
return 8 /* ObjectDefinePropertyExports */;
|
|
}
|
|
if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") {
|
|
return 9 /* ObjectDefinePrototypeProperty */;
|
|
}
|
|
return 7 /* ObjectDefinePropertyValue */;
|
|
}
|
|
if (expr.operatorToken.kind !== 63 /* EqualsToken */ || !isAccessExpression(expr.left) || isVoidZero(getRightMostAssignedExpression(expr))) {
|
|
return 0 /* None */;
|
|
}
|
|
if (isBindableStaticNameExpression(expr.left.expression, true) && getElementOrPropertyAccessName(expr.left) === "prototype" && isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
|
|
return 6 /* Prototype */;
|
|
}
|
|
return getAssignmentDeclarationPropertyAccessKind(expr.left);
|
|
}
|
|
function isVoidZero(node) {
|
|
return isVoidExpression(node) && isNumericLiteral(node.expression) && node.expression.text === "0";
|
|
}
|
|
function getElementOrPropertyAccessArgumentExpressionOrName(node) {
|
|
if (isPropertyAccessExpression(node)) {
|
|
return node.name;
|
|
}
|
|
const arg = skipParentheses(node.argumentExpression);
|
|
if (isNumericLiteral(arg) || isStringLiteralLike(arg)) {
|
|
return arg;
|
|
}
|
|
return node;
|
|
}
|
|
function getElementOrPropertyAccessName(node) {
|
|
const name = getElementOrPropertyAccessArgumentExpressionOrName(node);
|
|
if (name) {
|
|
if (isIdentifier(name)) {
|
|
return name.escapedText;
|
|
}
|
|
if (isStringLiteralLike(name) || isNumericLiteral(name)) {
|
|
return escapeLeadingUnderscores(name.text);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAssignmentDeclarationPropertyAccessKind(lhs) {
|
|
if (lhs.expression.kind === 108 /* ThisKeyword */) {
|
|
return 4 /* ThisProperty */;
|
|
} else if (isModuleExportsAccessExpression(lhs)) {
|
|
return 2 /* ModuleExports */;
|
|
} else if (isBindableStaticNameExpression(lhs.expression, true)) {
|
|
if (isPrototypeAccess(lhs.expression)) {
|
|
return 3 /* PrototypeProperty */;
|
|
}
|
|
let nextToLast = lhs;
|
|
while (!isIdentifier(nextToLast.expression)) {
|
|
nextToLast = nextToLast.expression;
|
|
}
|
|
const id = nextToLast.expression;
|
|
if ((id.escapedText === "exports" || id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") && isBindableStaticAccessExpression(lhs)) {
|
|
return 1 /* ExportsProperty */;
|
|
}
|
|
if (isBindableStaticNameExpression(lhs, true) || isElementAccessExpression(lhs) && isDynamicName(lhs)) {
|
|
return 5 /* Property */;
|
|
}
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function getInitializerOfBinaryExpression(expr) {
|
|
while (isBinaryExpression(expr.right)) {
|
|
expr = expr.right;
|
|
}
|
|
return expr.right;
|
|
}
|
|
function isPrototypePropertyAssignment(node) {
|
|
return isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 3 /* PrototypeProperty */;
|
|
}
|
|
function isSpecialPropertyDeclaration(expr) {
|
|
return isInJSFile(expr) && expr.parent && expr.parent.kind === 241 /* ExpressionStatement */ && (!isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) && !!getJSDocTypeTag(expr.parent);
|
|
}
|
|
function setValueDeclaration(symbol, node) {
|
|
const { valueDeclaration } = symbol;
|
|
if (!valueDeclaration || !(node.flags & 16777216 /* Ambient */ && !(valueDeclaration.flags & 16777216 /* Ambient */)) && (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) || valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration)) {
|
|
symbol.valueDeclaration = node;
|
|
}
|
|
}
|
|
function isFunctionSymbol(symbol) {
|
|
if (!symbol || !symbol.valueDeclaration) {
|
|
return false;
|
|
}
|
|
const decl = symbol.valueDeclaration;
|
|
return decl.kind === 259 /* FunctionDeclaration */ || isVariableDeclaration(decl) && decl.initializer && isFunctionLike(decl.initializer);
|
|
}
|
|
function tryGetModuleSpecifierFromDeclaration(node) {
|
|
var _a2, _b;
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return (_a2 = findAncestor(node.initializer, (node2) => isRequireCall(node2, true))) == null ? void 0 : _a2.arguments[0];
|
|
case 269 /* ImportDeclaration */:
|
|
return tryCast(node.moduleSpecifier, isStringLiteralLike);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return tryCast((_b = tryCast(node.moduleReference, isExternalModuleReference)) == null ? void 0 : _b.expression, isStringLiteralLike);
|
|
default:
|
|
Debug.assertNever(node);
|
|
}
|
|
}
|
|
function getExternalModuleName(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
return node.moduleSpecifier;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.moduleReference.kind === 280 /* ExternalModuleReference */ ? node.moduleReference.expression : void 0;
|
|
case 202 /* ImportType */:
|
|
return isLiteralImportTypeNode(node) ? node.argument.literal : void 0;
|
|
case 210 /* CallExpression */:
|
|
return node.arguments[0];
|
|
case 264 /* ModuleDeclaration */:
|
|
return node.name.kind === 10 /* StringLiteral */ ? node.name : void 0;
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function getNamespaceDeclarationNode(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return node.importClause && tryCast(node.importClause.namedBindings, isNamespaceImport);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node;
|
|
case 275 /* ExportDeclaration */:
|
|
return node.exportClause && tryCast(node.exportClause, isNamespaceExport);
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function isDefaultImport(node) {
|
|
return node.kind === 269 /* ImportDeclaration */ && !!node.importClause && !!node.importClause.name;
|
|
}
|
|
function forEachImportClauseDeclaration(node, action) {
|
|
if (node.name) {
|
|
const result = action(node);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (node.namedBindings) {
|
|
const result = isNamespaceImport(node.namedBindings) ? action(node.namedBindings) : forEach(node.namedBindings.elements, action);
|
|
if (result)
|
|
return result;
|
|
}
|
|
}
|
|
function hasQuestionToken(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 166 /* Parameter */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return node.questionToken !== void 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isJSDocConstructSignature(node) {
|
|
const param = isJSDocFunctionType(node) ? firstOrUndefined(node.parameters) : void 0;
|
|
const name = tryCast(param && param.name, isIdentifier);
|
|
return !!name && name.escapedText === "new";
|
|
}
|
|
function isJSDocTypeAlias(node) {
|
|
return node.kind === 348 /* JSDocTypedefTag */ || node.kind === 341 /* JSDocCallbackTag */ || node.kind === 342 /* JSDocEnumTag */;
|
|
}
|
|
function isTypeAlias(node) {
|
|
return isJSDocTypeAlias(node) || isTypeAliasDeclaration(node);
|
|
}
|
|
function getSourceOfAssignment(node) {
|
|
return isExpressionStatement(node) && isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 63 /* EqualsToken */ ? getRightMostAssignedExpression(node.expression) : void 0;
|
|
}
|
|
function getSourceOfDefaultedAssignment(node) {
|
|
return isExpressionStatement(node) && isBinaryExpression(node.expression) && getAssignmentDeclarationKind(node.expression) !== 0 /* None */ && isBinaryExpression(node.expression.right) && (node.expression.right.operatorToken.kind === 56 /* BarBarToken */ || node.expression.right.operatorToken.kind === 60 /* QuestionQuestionToken */) ? node.expression.right.right : void 0;
|
|
}
|
|
function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
const v = getSingleVariableOfVariableStatement(node);
|
|
return v && v.initializer;
|
|
case 169 /* PropertyDeclaration */:
|
|
return node.initializer;
|
|
case 299 /* PropertyAssignment */:
|
|
return node.initializer;
|
|
}
|
|
}
|
|
function getSingleVariableOfVariableStatement(node) {
|
|
return isVariableStatement(node) ? firstOrUndefined(node.declarationList.declarations) : void 0;
|
|
}
|
|
function getNestedModuleDeclaration(node) {
|
|
return isModuleDeclaration(node) && node.body && node.body.kind === 264 /* ModuleDeclaration */ ? node.body : void 0;
|
|
}
|
|
function getJSDocCommentsAndTags(hostNode, noCache) {
|
|
let result;
|
|
if (isVariableLike(hostNode) && hasInitializer(hostNode) && hasJSDocNodes(hostNode.initializer)) {
|
|
result = addRange(result, filterOwnedJSDocTags(hostNode, last(hostNode.initializer.jsDoc)));
|
|
}
|
|
let node = hostNode;
|
|
while (node && node.parent) {
|
|
if (hasJSDocNodes(node)) {
|
|
result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
|
|
}
|
|
if (node.kind === 166 /* Parameter */) {
|
|
result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
|
|
break;
|
|
}
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
result = addRange(result, (noCache ? getJSDocTypeParameterTagsNoCache : getJSDocTypeParameterTags)(node));
|
|
break;
|
|
}
|
|
node = getNextJSDocCommentLocation(node);
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function filterOwnedJSDocTags(hostNode, jsDoc) {
|
|
if (isJSDoc(jsDoc)) {
|
|
const ownedTags = filter(jsDoc.tags, (tag) => ownsJSDocTag(hostNode, tag));
|
|
return jsDoc.tags === ownedTags ? [jsDoc] : ownedTags;
|
|
}
|
|
return ownsJSDocTag(hostNode, jsDoc) ? [jsDoc] : void 0;
|
|
}
|
|
function ownsJSDocTag(hostNode, tag) {
|
|
return !isJSDocTypeTag(tag) || !tag.parent || !isJSDoc(tag.parent) || !isParenthesizedExpression(tag.parent.parent) || tag.parent.parent === hostNode;
|
|
}
|
|
function getNextJSDocCommentLocation(node) {
|
|
const parent = node.parent;
|
|
if (parent.kind === 299 /* PropertyAssignment */ || parent.kind === 274 /* ExportAssignment */ || parent.kind === 169 /* PropertyDeclaration */ || parent.kind === 241 /* ExpressionStatement */ && node.kind === 208 /* PropertyAccessExpression */ || parent.kind === 250 /* ReturnStatement */ || getNestedModuleDeclaration(parent) || isBinaryExpression(node) && node.operatorToken.kind === 63 /* EqualsToken */) {
|
|
return parent;
|
|
} else if (parent.parent && (getSingleVariableOfVariableStatement(parent.parent) === node || isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* 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;
|
|
}
|
|
}
|
|
function getParameterSymbolFromJSDoc(node) {
|
|
if (node.symbol) {
|
|
return node.symbol;
|
|
}
|
|
if (!isIdentifier(node.name)) {
|
|
return void 0;
|
|
}
|
|
const name = node.name.escapedText;
|
|
const decl = getHostSignatureFromJSDoc(node);
|
|
if (!decl) {
|
|
return void 0;
|
|
}
|
|
const parameter = find(decl.parameters, (p) => p.name.kind === 79 /* Identifier */ && p.name.escapedText === name);
|
|
return parameter && parameter.symbol;
|
|
}
|
|
function getEffectiveContainerForJSDocTemplateTag(node) {
|
|
if (isJSDoc(node.parent) && node.parent.tags) {
|
|
const typeAlias = find(node.parent.tags, isJSDocTypeAlias);
|
|
if (typeAlias) {
|
|
return typeAlias;
|
|
}
|
|
}
|
|
return getHostSignatureFromJSDoc(node);
|
|
}
|
|
function getHostSignatureFromJSDoc(node) {
|
|
const host = getEffectiveJSDocHost(node);
|
|
if (host) {
|
|
return isPropertySignature(host) && host.type && isFunctionLike(host.type) ? host.type : isFunctionLike(host) ? host : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getEffectiveJSDocHost(node) {
|
|
const host = getJSDocHost(node);
|
|
if (host) {
|
|
return getSourceOfDefaultedAssignment(host) || getSourceOfAssignment(host) || getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) || getSingleVariableOfVariableStatement(host) || getNestedModuleDeclaration(host) || host;
|
|
}
|
|
}
|
|
function getJSDocHost(node) {
|
|
const jsDoc = getJSDocRoot(node);
|
|
if (!jsDoc) {
|
|
return void 0;
|
|
}
|
|
const host = jsDoc.parent;
|
|
if (host && host.jsDoc && jsDoc === lastOrUndefined(host.jsDoc)) {
|
|
return host;
|
|
}
|
|
}
|
|
function getJSDocRoot(node) {
|
|
return findAncestor(node.parent, isJSDoc);
|
|
}
|
|
function getTypeParameterFromJsDoc(node) {
|
|
const name = node.name.escapedText;
|
|
const { typeParameters } = node.parent.parent.parent;
|
|
return typeParameters && find(typeParameters, (p) => p.name.escapedText === name);
|
|
}
|
|
function getAssignmentTargetKind(node) {
|
|
let parent = node.parent;
|
|
while (true) {
|
|
switch (parent.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
const binaryOperator = parent.operatorToken.kind;
|
|
return isAssignmentOperator(binaryOperator) && parent.left === node ? binaryOperator === 63 /* EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 /* Definite */ : 2 /* Compound */ : 0 /* None */;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
const unaryOperator = parent.operator;
|
|
return unaryOperator === 45 /* PlusPlusToken */ || unaryOperator === 46 /* MinusMinusToken */ ? 2 /* Compound */ : 0 /* None */;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return parent.initializer === node ? 1 /* Definite */ : 0 /* None */;
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 232 /* NonNullExpression */:
|
|
node = parent;
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
node = parent.parent;
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (parent.name !== node) {
|
|
return 0 /* None */;
|
|
}
|
|
node = parent.parent;
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
if (parent.name === node) {
|
|
return 0 /* None */;
|
|
}
|
|
node = parent.parent;
|
|
break;
|
|
default:
|
|
return 0 /* None */;
|
|
}
|
|
parent = node.parent;
|
|
}
|
|
}
|
|
function isAssignmentTarget(node) {
|
|
return getAssignmentTargetKind(node) !== 0 /* None */;
|
|
}
|
|
function isNodeWithPossibleHoistedDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 240 /* VariableStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 266 /* CaseBlock */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 253 /* LabeledStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 295 /* CatchClause */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isValueSignatureDeclaration(node) {
|
|
return isFunctionExpression(node) || isArrowFunction(node) || isMethodOrAccessor(node) || isFunctionDeclaration(node) || isConstructorDeclaration(node);
|
|
}
|
|
function walkUp(node, kind) {
|
|
while (node && node.kind === kind) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function walkUpParenthesizedTypes(node) {
|
|
return walkUp(node, 193 /* ParenthesizedType */);
|
|
}
|
|
function walkUpParenthesizedExpressions(node) {
|
|
return walkUp(node, 214 /* ParenthesizedExpression */);
|
|
}
|
|
function walkUpParenthesizedTypesAndGetParentAndChild(node) {
|
|
let child;
|
|
while (node && node.kind === 193 /* ParenthesizedType */) {
|
|
child = node;
|
|
node = node.parent;
|
|
}
|
|
return [child, node];
|
|
}
|
|
function skipTypeParentheses(node) {
|
|
while (isParenthesizedTypeNode(node))
|
|
node = node.type;
|
|
return node;
|
|
}
|
|
function skipParentheses(node, excludeJSDocTypeAssertions) {
|
|
const flags = excludeJSDocTypeAssertions ? 1 /* Parentheses */ | 16 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */;
|
|
return skipOuterExpressions(node, flags);
|
|
}
|
|
function isDeleteTarget(node) {
|
|
if (node.kind !== 208 /* PropertyAccessExpression */ && node.kind !== 209 /* ElementAccessExpression */) {
|
|
return false;
|
|
}
|
|
node = walkUpParenthesizedExpressions(node.parent);
|
|
return node && node.kind === 217 /* DeleteExpression */;
|
|
}
|
|
function isNodeDescendantOf(node, ancestor) {
|
|
while (node) {
|
|
if (node === ancestor)
|
|
return true;
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function isDeclarationName(name) {
|
|
return !isSourceFile(name) && !isBindingPattern(name) && isDeclaration(name.parent) && name.parent.name === name;
|
|
}
|
|
function isLiteralComputedPropertyDeclarationName(node) {
|
|
return isStringOrNumericLiteralLike(node) && node.parent.kind === 164 /* ComputedPropertyName */ && isDeclaration(node.parent.parent);
|
|
}
|
|
function isIdentifierName(node) {
|
|
const parent = node.parent;
|
|
switch (parent.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 302 /* EnumMember */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return parent.name === node;
|
|
case 163 /* QualifiedName */:
|
|
return parent.right === node;
|
|
case 205 /* BindingElement */:
|
|
case 273 /* ImportSpecifier */:
|
|
return parent.propertyName === node;
|
|
case 278 /* ExportSpecifier */:
|
|
case 288 /* JsxAttribute */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getAliasDeclarationFromName(node) {
|
|
switch (node.parent.kind) {
|
|
case 270 /* ImportClause */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 271 /* NamespaceImport */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 274 /* ExportAssignment */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 277 /* NamespaceExport */:
|
|
return node.parent;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.parent;
|
|
} while (node.parent.kind === 163 /* QualifiedName */);
|
|
return getAliasDeclarationFromName(node);
|
|
}
|
|
}
|
|
function isAliasableExpression(e) {
|
|
return isEntityNameExpression(e) || isClassExpression(e);
|
|
}
|
|
function exportAssignmentIsAlias(node) {
|
|
const e = getExportAssignmentExpression(node);
|
|
return isAliasableExpression(e);
|
|
}
|
|
function getExportAssignmentExpression(node) {
|
|
return isExportAssignment(node) ? node.expression : node.right;
|
|
}
|
|
function getPropertyAssignmentAliasLikeExpression(node) {
|
|
return node.kind === 300 /* ShorthandPropertyAssignment */ ? node.name : node.kind === 299 /* PropertyAssignment */ ? node.initializer : node.parent.right;
|
|
}
|
|
function getEffectiveBaseTypeNode(node) {
|
|
const baseType = getClassExtendsHeritageElement(node);
|
|
if (baseType && isInJSFile(node)) {
|
|
const tag = getJSDocAugmentsTag(node);
|
|
if (tag) {
|
|
return tag.class;
|
|
}
|
|
}
|
|
return baseType;
|
|
}
|
|
function getClassExtendsHeritageElement(node) {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 94 /* ExtendsKeyword */);
|
|
return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : void 0;
|
|
}
|
|
function getEffectiveImplementsTypeNodes(node) {
|
|
if (isInJSFile(node)) {
|
|
return getJSDocImplementsTags(node).map((n) => n.class);
|
|
} else {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 117 /* ImplementsKeyword */);
|
|
return heritageClause == null ? void 0 : heritageClause.types;
|
|
}
|
|
}
|
|
function getInterfaceBaseTypeNodes(node) {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 94 /* ExtendsKeyword */);
|
|
return heritageClause ? heritageClause.types : void 0;
|
|
}
|
|
function getHeritageClause(clauses, kind) {
|
|
if (clauses) {
|
|
for (const clause of clauses) {
|
|
if (clause.token === kind) {
|
|
return clause;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAncestor(node, kind) {
|
|
while (node) {
|
|
if (node.kind === kind) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isKeyword(token) {
|
|
return 81 /* FirstKeyword */ <= token && token <= 162 /* LastKeyword */;
|
|
}
|
|
function isContextualKeyword(token) {
|
|
return 126 /* FirstContextualKeyword */ <= token && token <= 162 /* LastContextualKeyword */;
|
|
}
|
|
function isNonContextualKeyword(token) {
|
|
return isKeyword(token) && !isContextualKeyword(token);
|
|
}
|
|
function isStringANonContextualKeyword(name) {
|
|
const token = stringToToken(name);
|
|
return token !== void 0 && isNonContextualKeyword(token);
|
|
}
|
|
function isIdentifierANonContextualKeyword({ originalKeywordKind }) {
|
|
return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind);
|
|
}
|
|
function getFunctionFlags(node) {
|
|
if (!node) {
|
|
return 4 /* Invalid */;
|
|
}
|
|
let flags = 0 /* Normal */;
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (node.asteriskToken) {
|
|
flags |= 1 /* Generator */;
|
|
}
|
|
case 216 /* ArrowFunction */:
|
|
if (hasSyntacticModifier(node, 512 /* Async */)) {
|
|
flags |= 2 /* Async */;
|
|
}
|
|
break;
|
|
}
|
|
if (!node.body) {
|
|
flags |= 4 /* Invalid */;
|
|
}
|
|
return flags;
|
|
}
|
|
function isAsyncFunction(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 512 /* Async */);
|
|
}
|
|
return false;
|
|
}
|
|
function isStringOrNumericLiteralLike(node) {
|
|
return isStringLiteralLike(node) || isNumericLiteral(node);
|
|
}
|
|
function isSignedNumericLiteral(node) {
|
|
return isPrefixUnaryExpression(node) && (node.operator === 39 /* PlusToken */ || node.operator === 40 /* MinusToken */) && isNumericLiteral(node.operand);
|
|
}
|
|
function hasDynamicName(declaration) {
|
|
const name = getNameOfDeclaration(declaration);
|
|
return !!name && isDynamicName(name);
|
|
}
|
|
function isDynamicName(name) {
|
|
if (!(name.kind === 164 /* ComputedPropertyName */ || name.kind === 209 /* ElementAccessExpression */)) {
|
|
return false;
|
|
}
|
|
const expr = isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression;
|
|
return !isStringOrNumericLiteralLike(expr) && !isSignedNumericLiteral(expr);
|
|
}
|
|
function getPropertyNameForPropertyNameNode(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return name.escapedText;
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
return escapeLeadingUnderscores(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
const nameExpression = name.expression;
|
|
if (isStringOrNumericLiteralLike(nameExpression)) {
|
|
return escapeLeadingUnderscores(nameExpression.text);
|
|
} else if (isSignedNumericLiteral(nameExpression)) {
|
|
if (nameExpression.operator === 40 /* MinusToken */) {
|
|
return tokenToString(nameExpression.operator) + nameExpression.operand.text;
|
|
}
|
|
return nameExpression.operand.text;
|
|
}
|
|
return void 0;
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function isPropertyNameLiteral(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getTextOfIdentifierOrLiteral(node) {
|
|
return isMemberName(node) ? idText(node) : node.text;
|
|
}
|
|
function getEscapedTextOfIdentifierOrLiteral(node) {
|
|
return isMemberName(node) ? node.escapedText : escapeLeadingUnderscores(node.text);
|
|
}
|
|
function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) {
|
|
return `__#${getSymbolId(containingClassSymbol)}@${description}`;
|
|
}
|
|
function isKnownSymbol(symbol) {
|
|
return startsWith(symbol.escapedName, "__@");
|
|
}
|
|
function isPushOrUnshiftIdentifier(node) {
|
|
return node.escapedText === "push" || node.escapedText === "unshift";
|
|
}
|
|
function isParameterDeclaration(node) {
|
|
const root = getRootDeclaration(node);
|
|
return root.kind === 166 /* Parameter */;
|
|
}
|
|
function getRootDeclaration(node) {
|
|
while (node.kind === 205 /* BindingElement */) {
|
|
node = node.parent.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function nodeStartsNewLexicalEnvironment(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 215 /* FunctionExpression */ || kind === 259 /* FunctionDeclaration */ || kind === 216 /* ArrowFunction */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 264 /* ModuleDeclaration */ || kind === 308 /* SourceFile */;
|
|
}
|
|
function nodeIsSynthesized(range) {
|
|
return positionIsSynthesized(range.pos) || positionIsSynthesized(range.end);
|
|
}
|
|
function getExpressionAssociativity(expression) {
|
|
const operator = getOperator(expression);
|
|
const hasArguments = expression.kind === 211 /* NewExpression */ && expression.arguments !== void 0;
|
|
return getOperatorAssociativity(expression.kind, operator, hasArguments);
|
|
}
|
|
function getOperatorAssociativity(kind, operator, hasArguments) {
|
|
switch (kind) {
|
|
case 211 /* NewExpression */:
|
|
return hasArguments ? 0 /* Left */ : 1 /* Right */;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 224 /* ConditionalExpression */:
|
|
case 226 /* YieldExpression */:
|
|
return 1 /* Right */;
|
|
case 223 /* BinaryExpression */:
|
|
switch (operator) {
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 1 /* Right */;
|
|
}
|
|
}
|
|
return 0 /* Left */;
|
|
}
|
|
function getExpressionPrecedence(expression) {
|
|
const operator = getOperator(expression);
|
|
const hasArguments = expression.kind === 211 /* NewExpression */ && expression.arguments !== void 0;
|
|
return getOperatorPrecedence(expression.kind, operator, hasArguments);
|
|
}
|
|
function getOperator(expression) {
|
|
if (expression.kind === 223 /* BinaryExpression */) {
|
|
return expression.operatorToken.kind;
|
|
} else if (expression.kind === 221 /* PrefixUnaryExpression */ || expression.kind === 222 /* PostfixUnaryExpression */) {
|
|
return expression.operator;
|
|
} else {
|
|
return expression.kind;
|
|
}
|
|
}
|
|
function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
|
|
switch (nodeKind) {
|
|
case 354 /* CommaListExpression */:
|
|
return 0 /* Comma */;
|
|
case 227 /* SpreadElement */:
|
|
return 1 /* Spread */;
|
|
case 226 /* YieldExpression */:
|
|
return 2 /* Yield */;
|
|
case 224 /* ConditionalExpression */:
|
|
return 4 /* Conditional */;
|
|
case 223 /* BinaryExpression */:
|
|
switch (operatorKind) {
|
|
case 27 /* CommaToken */:
|
|
return 0 /* Comma */;
|
|
case 63 /* EqualsToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 3 /* Assignment */;
|
|
default:
|
|
return getBinaryOperatorPrecedence(operatorKind);
|
|
}
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
return 16 /* Unary */;
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return 17 /* Update */;
|
|
case 210 /* CallExpression */:
|
|
return 18 /* LeftHandSide */;
|
|
case 211 /* NewExpression */:
|
|
return hasArguments ? 19 /* Member */ : 18 /* LeftHandSide */;
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 233 /* MetaProperty */:
|
|
return 19 /* Member */;
|
|
case 231 /* AsExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return 11 /* Relational */;
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 228 /* ClassExpression */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
return 20 /* Primary */;
|
|
default:
|
|
return -1 /* Invalid */;
|
|
}
|
|
}
|
|
function getBinaryOperatorPrecedence(kind) {
|
|
switch (kind) {
|
|
case 60 /* QuestionQuestionToken */:
|
|
return 4 /* Coalesce */;
|
|
case 56 /* BarBarToken */:
|
|
return 5 /* LogicalOR */;
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
return 6 /* LogicalAND */;
|
|
case 51 /* BarToken */:
|
|
return 7 /* BitwiseOR */;
|
|
case 52 /* CaretToken */:
|
|
return 8 /* BitwiseXOR */;
|
|
case 50 /* AmpersandToken */:
|
|
return 9 /* BitwiseAND */;
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
return 10 /* Equality */;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
case 102 /* InstanceOfKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 128 /* AsKeyword */:
|
|
case 150 /* SatisfiesKeyword */:
|
|
return 11 /* Relational */;
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
return 12 /* Shift */;
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
return 13 /* Additive */;
|
|
case 41 /* AsteriskToken */:
|
|
case 43 /* SlashToken */:
|
|
case 44 /* PercentToken */:
|
|
return 14 /* Multiplicative */;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return 15 /* Exponentiation */;
|
|
}
|
|
return -1;
|
|
}
|
|
function getSemanticJsxChildren(children) {
|
|
return filter(children, (i) => {
|
|
switch (i.kind) {
|
|
case 291 /* JsxExpression */:
|
|
return !!i.expression;
|
|
case 11 /* JsxText */:
|
|
return !i.containsOnlyTriviaWhiteSpaces;
|
|
default:
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
function createDiagnosticCollection() {
|
|
let nonFileDiagnostics = [];
|
|
const filesWithDiagnostics = [];
|
|
const fileDiagnostics = /* @__PURE__ */ new Map();
|
|
let hasReadNonFileDiagnostics = false;
|
|
return {
|
|
add,
|
|
lookup,
|
|
getGlobalDiagnostics,
|
|
getDiagnostics
|
|
};
|
|
function lookup(diagnostic) {
|
|
let diagnostics;
|
|
if (diagnostic.file) {
|
|
diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
|
|
} else {
|
|
diagnostics = nonFileDiagnostics;
|
|
}
|
|
if (!diagnostics) {
|
|
return void 0;
|
|
}
|
|
const result = binarySearch(diagnostics, diagnostic, identity, compareDiagnosticsSkipRelatedInformation);
|
|
if (result >= 0) {
|
|
return diagnostics[result];
|
|
}
|
|
return void 0;
|
|
}
|
|
function add(diagnostic) {
|
|
let diagnostics;
|
|
if (diagnostic.file) {
|
|
diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
|
|
if (!diagnostics) {
|
|
diagnostics = [];
|
|
fileDiagnostics.set(diagnostic.file.fileName, diagnostics);
|
|
insertSorted(filesWithDiagnostics, diagnostic.file.fileName, compareStringsCaseSensitive);
|
|
}
|
|
} else {
|
|
if (hasReadNonFileDiagnostics) {
|
|
hasReadNonFileDiagnostics = false;
|
|
nonFileDiagnostics = nonFileDiagnostics.slice();
|
|
}
|
|
diagnostics = nonFileDiagnostics;
|
|
}
|
|
insertSorted(diagnostics, diagnostic, compareDiagnosticsSkipRelatedInformation);
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
hasReadNonFileDiagnostics = true;
|
|
return nonFileDiagnostics;
|
|
}
|
|
function getDiagnostics(fileName) {
|
|
if (fileName) {
|
|
return fileDiagnostics.get(fileName) || [];
|
|
}
|
|
const fileDiags = flatMapToMutable(filesWithDiagnostics, (f) => fileDiagnostics.get(f));
|
|
if (!nonFileDiagnostics.length) {
|
|
return fileDiags;
|
|
}
|
|
fileDiags.unshift(...nonFileDiagnostics);
|
|
return fileDiags;
|
|
}
|
|
}
|
|
var templateSubstitutionRegExp = /\$\{/g;
|
|
function escapeTemplateSubstitution(str) {
|
|
return str.replace(templateSubstitutionRegExp, "\\${");
|
|
}
|
|
function hasInvalidEscape(template) {
|
|
return template && !!(isNoSubstitutionTemplateLiteral(template) ? template.templateFlags : template.head.templateFlags || some(template.templateSpans, (span) => !!span.literal.templateFlags));
|
|
}
|
|
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;
|
|
var backtickQuoteEscapedCharsRegExp = /\r\n|[\\\`\u0000-\u001f\t\v\f\b\r\u2028\u2029\u0085]/g;
|
|
var escapedCharsMap = new Map(getEntries({
|
|
" ": "\\t",
|
|
"\v": "\\v",
|
|
"\f": "\\f",
|
|
"\b": "\\b",
|
|
"\r": "\\r",
|
|
"\n": "\\n",
|
|
"\\": "\\\\",
|
|
'"': '\\"',
|
|
"'": "\\'",
|
|
"`": "\\`",
|
|
"\u2028": "\\u2028",
|
|
"\u2029": "\\u2029",
|
|
"\x85": "\\u0085",
|
|
"\r\n": "\\r\\n"
|
|
}));
|
|
function encodeUtf16EscapeSequence(charCode) {
|
|
const hexCharCode = charCode.toString(16).toUpperCase();
|
|
const paddedHexCode = ("0000" + hexCharCode).slice(-4);
|
|
return "\\u" + paddedHexCode;
|
|
}
|
|
function getReplacement(c, offset, input) {
|
|
if (c.charCodeAt(0) === 0 /* nullCharacter */) {
|
|
const lookAhead = input.charCodeAt(offset + c.length);
|
|
if (lookAhead >= 48 /* _0 */ && lookAhead <= 57 /* _9 */) {
|
|
return "\\x00";
|
|
}
|
|
return "\\0";
|
|
}
|
|
return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0));
|
|
}
|
|
function escapeString(s, quoteChar) {
|
|
const escapedCharsRegExp = quoteChar === 96 /* backtick */ ? backtickQuoteEscapedCharsRegExp : quoteChar === 39 /* singleQuote */ ? singleQuoteEscapedCharsRegExp : doubleQuoteEscapedCharsRegExp;
|
|
return s.replace(escapedCharsRegExp, getReplacement);
|
|
}
|
|
var nonAsciiCharacters = /[^\u0000-\u007F]/g;
|
|
function escapeNonAsciiString(s, quoteChar) {
|
|
s = escapeString(s, quoteChar);
|
|
return nonAsciiCharacters.test(s) ? s.replace(nonAsciiCharacters, (c) => encodeUtf16EscapeSequence(c.charCodeAt(0))) : s;
|
|
}
|
|
var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g;
|
|
var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g;
|
|
var jsxEscapedCharsMap = new Map(getEntries({
|
|
'"': """,
|
|
"'": "'"
|
|
}));
|
|
function encodeJsxCharacterEntity(charCode) {
|
|
const hexCharCode = charCode.toString(16).toUpperCase();
|
|
return "&#x" + hexCharCode + ";";
|
|
}
|
|
function getJsxAttributeStringReplacement(c) {
|
|
if (c.charCodeAt(0) === 0 /* nullCharacter */) {
|
|
return "�";
|
|
}
|
|
return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0));
|
|
}
|
|
function escapeJsxAttributeString(s, quoteChar) {
|
|
const escapedCharsRegExp = quoteChar === 39 /* singleQuote */ ? jsxSingleQuoteEscapedCharsRegExp : jsxDoubleQuoteEscapedCharsRegExp;
|
|
return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement);
|
|
}
|
|
function stripQuotes(name) {
|
|
const length2 = name.length;
|
|
if (length2 >= 2 && name.charCodeAt(0) === name.charCodeAt(length2 - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
|
|
return name.substring(1, length2 - 1);
|
|
}
|
|
return name;
|
|
}
|
|
function isQuoteOrBacktick(charCode) {
|
|
return charCode === 39 /* singleQuote */ || charCode === 34 /* doubleQuote */ || charCode === 96 /* backtick */;
|
|
}
|
|
function isIntrinsicJsxName(name) {
|
|
const ch = name.charCodeAt(0);
|
|
return ch >= 97 /* a */ && ch <= 122 /* z */ || stringContains(name, "-") || stringContains(name, ":");
|
|
}
|
|
var indentStrings = ["", " "];
|
|
function getIndentString(level) {
|
|
const singleLevel = indentStrings[1];
|
|
for (let current = indentStrings.length; current <= level; current++) {
|
|
indentStrings.push(indentStrings[current - 1] + singleLevel);
|
|
}
|
|
return indentStrings[level];
|
|
}
|
|
function getIndentSize() {
|
|
return indentStrings[1].length;
|
|
}
|
|
function isNightly() {
|
|
return stringContains(version, "-dev") || stringContains(version, "-insiders");
|
|
}
|
|
function createTextWriter(newLine) {
|
|
let output;
|
|
let indent2;
|
|
let lineStart;
|
|
let lineCount;
|
|
let linePos;
|
|
let hasTrailingComment = false;
|
|
function updateLineCountAndPosFor(s) {
|
|
const lineStartsOfS = computeLineStarts(s);
|
|
if (lineStartsOfS.length > 1) {
|
|
lineCount = lineCount + lineStartsOfS.length - 1;
|
|
linePos = output.length - s.length + last(lineStartsOfS);
|
|
lineStart = linePos - output.length === 0;
|
|
} else {
|
|
lineStart = false;
|
|
}
|
|
}
|
|
function writeText(s) {
|
|
if (s && s.length) {
|
|
if (lineStart) {
|
|
s = getIndentString(indent2) + 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 = "";
|
|
indent2 = 0;
|
|
lineStart = true;
|
|
lineCount = 0;
|
|
linePos = 0;
|
|
hasTrailingComment = false;
|
|
}
|
|
function rawWrite(s) {
|
|
if (s !== void 0) {
|
|
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,
|
|
rawWrite,
|
|
writeLiteral,
|
|
writeLine,
|
|
increaseIndent: () => {
|
|
indent2++;
|
|
},
|
|
decreaseIndent: () => {
|
|
indent2--;
|
|
},
|
|
getIndent: () => indent2,
|
|
getTextPos: () => output.length,
|
|
getLine: () => lineCount,
|
|
getColumn: () => lineStart ? indent2 * getIndentSize() : output.length - linePos,
|
|
getText: () => output,
|
|
isAtStartOfLine: () => lineStart,
|
|
hasTrailingComment: () => hasTrailingComment,
|
|
hasTrailingWhitespace: () => !!output.length && isWhiteSpaceLike(output.charCodeAt(output.length - 1)),
|
|
clear: reset,
|
|
reportInaccessibleThisError: noop,
|
|
reportPrivateInBaseOfClassExpression: noop,
|
|
reportInaccessibleUniqueSymbolError: noop,
|
|
trackSymbol: () => false,
|
|
writeKeyword: write,
|
|
writeOperator: write,
|
|
writeParameter: write,
|
|
writeProperty: write,
|
|
writePunctuation: write,
|
|
writeSpace: write,
|
|
writeStringLiteral: write,
|
|
writeSymbol: (s, _) => write(s),
|
|
writeTrailingSemicolon: write,
|
|
writeComment,
|
|
getTextPosWithWriteLine
|
|
};
|
|
}
|
|
function getTrailingSemicolonDeferringWriter(writer) {
|
|
let pendingTrailingSemicolon = false;
|
|
function commitPendingTrailingSemicolon() {
|
|
if (pendingTrailingSemicolon) {
|
|
writer.writeTrailingSemicolon(";");
|
|
pendingTrailingSemicolon = false;
|
|
}
|
|
}
|
|
return {
|
|
...writer,
|
|
writeTrailingSemicolon() {
|
|
pendingTrailingSemicolon = true;
|
|
},
|
|
writeLiteral(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeLiteral(s);
|
|
},
|
|
writeStringLiteral(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeStringLiteral(s);
|
|
},
|
|
writeSymbol(s, sym) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeSymbol(s, sym);
|
|
},
|
|
writePunctuation(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writePunctuation(s);
|
|
},
|
|
writeKeyword(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeKeyword(s);
|
|
},
|
|
writeOperator(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeOperator(s);
|
|
},
|
|
writeParameter(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeParameter(s);
|
|
},
|
|
writeSpace(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeSpace(s);
|
|
},
|
|
writeProperty(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeProperty(s);
|
|
},
|
|
writeComment(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeComment(s);
|
|
},
|
|
writeLine() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeLine();
|
|
},
|
|
increaseIndent() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.increaseIndent();
|
|
},
|
|
decreaseIndent() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.decreaseIndent();
|
|
}
|
|
};
|
|
}
|
|
function hostUsesCaseSensitiveFileNames(host) {
|
|
return host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : false;
|
|
}
|
|
function hostGetCanonicalFileName(host) {
|
|
return createGetCanonicalFileName(hostUsesCaseSensitiveFileNames(host));
|
|
}
|
|
function getResolvedExternalModuleName(host, file, referenceFile) {
|
|
return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
|
|
}
|
|
function getCanonicalAbsolutePath(host, path) {
|
|
return host.getCanonicalFileName(getNormalizedAbsolutePath(path, host.getCurrentDirectory()));
|
|
}
|
|
function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
|
|
const file = resolver.getExternalModuleFileFromDeclaration(declaration);
|
|
if (!file || file.isDeclarationFile) {
|
|
return void 0;
|
|
}
|
|
const specifier = getExternalModuleName(declaration);
|
|
if (specifier && isStringLiteralLike(specifier) && !pathIsRelative(specifier.text) && getCanonicalAbsolutePath(host, file.path).indexOf(getCanonicalAbsolutePath(host, ensureTrailingDirectorySeparator(host.getCommonSourceDirectory()))) === -1) {
|
|
return void 0;
|
|
}
|
|
return getResolvedExternalModuleName(host, file);
|
|
}
|
|
function getExternalModuleNameFromPath(host, fileName, referencePath) {
|
|
const getCanonicalFileName = (f) => host.getCanonicalFileName(f);
|
|
const dir = toPath(referencePath ? getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName);
|
|
const filePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
|
|
const relativePath = getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, false);
|
|
const extensionless = removeFileExtension(relativePath);
|
|
return referencePath ? ensurePathIsNonModuleName(extensionless) : extensionless;
|
|
}
|
|
function getOwnEmitOutputFilePath(fileName, host, extension) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
let emitOutputFilePathWithoutExtension;
|
|
if (compilerOptions.outDir) {
|
|
emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(fileName, host, compilerOptions.outDir));
|
|
} else {
|
|
emitOutputFilePathWithoutExtension = removeFileExtension(fileName);
|
|
}
|
|
return emitOutputFilePathWithoutExtension + extension;
|
|
}
|
|
function getDeclarationEmitOutputFilePath(fileName, host) {
|
|
return getDeclarationEmitOutputFilePathWorker(fileName, host.getCompilerOptions(), host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f));
|
|
}
|
|
function getDeclarationEmitOutputFilePathWorker(fileName, options, currentDirectory, commonSourceDirectory, getCanonicalFileName) {
|
|
const outputDir = options.declarationDir || options.outDir;
|
|
const path = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName) : fileName;
|
|
const declarationExtension = getDeclarationEmitExtensionForPath(path);
|
|
return removeFileExtension(path) + declarationExtension;
|
|
}
|
|
function getDeclarationEmitExtensionForPath(path) {
|
|
return fileExtensionIsOneOf(path, [".mjs" /* Mjs */, ".mts" /* Mts */]) ? ".d.mts" /* Dmts */ : fileExtensionIsOneOf(path, [".cjs" /* Cjs */, ".cts" /* Cts */]) ? ".d.cts" /* Dcts */ : fileExtensionIsOneOf(path, [".json" /* Json */]) ? `.json.d.ts` : ".d.ts" /* Dts */;
|
|
}
|
|
function getPossibleOriginalInputExtensionForExtension(path) {
|
|
return fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] : fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] : fileExtensionIsOneOf(path, [`.json.d.ts`]) ? [".json" /* Json */] : [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */];
|
|
}
|
|
function outFile(options) {
|
|
return options.outFile || options.out;
|
|
}
|
|
function getPathsBasePath(options, host) {
|
|
var _a2, _b;
|
|
if (!options.paths)
|
|
return void 0;
|
|
return (_b = options.baseUrl) != null ? _b : Debug.checkDefined(options.pathsBasePath || ((_a2 = host.getCurrentDirectory) == null ? void 0 : _a2.call(host)), "Encountered 'paths' without a 'baseUrl', config file, or host 'getCurrentDirectory'.");
|
|
}
|
|
function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) {
|
|
const options = host.getCompilerOptions();
|
|
if (outFile(options)) {
|
|
const moduleKind = getEmitModuleKind(options);
|
|
const moduleEmitEnabled = options.emitDeclarationOnly || moduleKind === 2 /* AMD */ || moduleKind === 4 /* System */;
|
|
return filter(
|
|
host.getSourceFiles(),
|
|
(sourceFile) => (moduleEmitEnabled || !isExternalModule(sourceFile)) && sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit)
|
|
);
|
|
} else {
|
|
const sourceFiles = targetSourceFile === void 0 ? host.getSourceFiles() : [targetSourceFile];
|
|
return filter(
|
|
sourceFiles,
|
|
(sourceFile) => sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit)
|
|
);
|
|
}
|
|
}
|
|
function sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit) {
|
|
const options = host.getCompilerOptions();
|
|
return !(options.noEmitForJsFiles && isSourceFileJS(sourceFile)) && !sourceFile.isDeclarationFile && !host.isSourceFileFromExternalLibrary(sourceFile) && (forceDtsEmit || !(isJsonSourceFile(sourceFile) && host.getResolvedProjectReferenceToRedirect(sourceFile.fileName)) && !host.isSourceOfProjectReferenceRedirect(sourceFile.fileName));
|
|
}
|
|
function getSourceFilePathInNewDir(fileName, host, newDirPath) {
|
|
return getSourceFilePathInNewDirWorker(fileName, newDirPath, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f));
|
|
}
|
|
function getSourceFilePathInNewDirWorker(fileName, newDirPath, currentDirectory, commonSourceDirectory, getCanonicalFileName) {
|
|
let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
|
|
const isSourceFileInCommonSourceDirectory = getCanonicalFileName(sourceFilePath).indexOf(getCanonicalFileName(commonSourceDirectory)) === 0;
|
|
sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath;
|
|
return combinePaths(newDirPath, sourceFilePath);
|
|
}
|
|
function writeFile(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) {
|
|
host.writeFile(fileName, text, writeByteOrderMark, (hostErrorMessage) => {
|
|
diagnostics.add(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
|
|
}, sourceFiles, data);
|
|
}
|
|
function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) {
|
|
if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
|
|
const parentDirectory = getDirectoryPath(directoryPath);
|
|
ensureDirectoriesExist(parentDirectory, createDirectory, directoryExists);
|
|
createDirectory(directoryPath);
|
|
}
|
|
}
|
|
function writeFileEnsuringDirectories(path, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
|
|
try {
|
|
writeFile2(path, data, writeByteOrderMark);
|
|
} catch (e) {
|
|
ensureDirectoriesExist(getDirectoryPath(normalizePath(path)), createDirectory, directoryExists);
|
|
writeFile2(path, data, writeByteOrderMark);
|
|
}
|
|
}
|
|
function getLineOfLocalPositionFromLineMap(lineMap, pos) {
|
|
return computeLineOfPosition(lineMap, pos);
|
|
}
|
|
function getFirstConstructorWithBody(node) {
|
|
return find(node.members, (member) => isConstructorDeclaration(member) && nodeIsPresent(member.body));
|
|
}
|
|
function getSetAccessorValueParameter(accessor) {
|
|
if (accessor && accessor.parameters.length > 0) {
|
|
const hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]);
|
|
return accessor.parameters[hasThis ? 1 : 0];
|
|
}
|
|
}
|
|
function getSetAccessorTypeAnnotationNode(accessor) {
|
|
const parameter = getSetAccessorValueParameter(accessor);
|
|
return parameter && parameter.type;
|
|
}
|
|
function getThisParameter(signature) {
|
|
if (signature.parameters.length && !isJSDocSignature(signature)) {
|
|
const thisParameter = signature.parameters[0];
|
|
if (parameterIsThisKeyword(thisParameter)) {
|
|
return thisParameter;
|
|
}
|
|
}
|
|
}
|
|
function parameterIsThisKeyword(parameter) {
|
|
return isThisIdentifier(parameter.name);
|
|
}
|
|
function isThisIdentifier(node) {
|
|
return !!node && node.kind === 79 /* Identifier */ && identifierIsThisKeyword(node);
|
|
}
|
|
function isThisInTypeQuery(node) {
|
|
if (!isThisIdentifier(node)) {
|
|
return false;
|
|
}
|
|
while (isQualifiedName(node.parent) && node.parent.left === node) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */;
|
|
}
|
|
function identifierIsThisKeyword(id) {
|
|
return id.originalKeywordKind === 108 /* ThisKeyword */;
|
|
}
|
|
function getAllAccessorDeclarations(declarations, accessor) {
|
|
let firstAccessor;
|
|
let secondAccessor;
|
|
let getAccessor;
|
|
let setAccessor;
|
|
if (hasDynamicName(accessor)) {
|
|
firstAccessor = accessor;
|
|
if (accessor.kind === 174 /* GetAccessor */) {
|
|
getAccessor = accessor;
|
|
} else if (accessor.kind === 175 /* SetAccessor */) {
|
|
setAccessor = accessor;
|
|
} else {
|
|
Debug.fail("Accessor has wrong kind");
|
|
}
|
|
} else {
|
|
forEach(declarations, (member) => {
|
|
if (isAccessor(member) && isStatic(member) === isStatic(accessor)) {
|
|
const memberName = getPropertyNameForPropertyNameNode(member.name);
|
|
const accessorName = getPropertyNameForPropertyNameNode(accessor.name);
|
|
if (memberName === accessorName) {
|
|
if (!firstAccessor) {
|
|
firstAccessor = member;
|
|
} else if (!secondAccessor) {
|
|
secondAccessor = member;
|
|
}
|
|
if (member.kind === 174 /* GetAccessor */ && !getAccessor) {
|
|
getAccessor = member;
|
|
}
|
|
if (member.kind === 175 /* SetAccessor */ && !setAccessor) {
|
|
setAccessor = member;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
firstAccessor,
|
|
secondAccessor,
|
|
getAccessor,
|
|
setAccessor
|
|
};
|
|
}
|
|
function getEffectiveTypeAnnotationNode(node) {
|
|
if (!isInJSFile(node) && isFunctionDeclaration(node))
|
|
return void 0;
|
|
const type = node.type;
|
|
if (type || !isInJSFile(node))
|
|
return type;
|
|
return isJSDocPropertyLikeTag(node) ? node.typeExpression && node.typeExpression.type : getJSDocType(node);
|
|
}
|
|
function getEffectiveReturnTypeNode(node) {
|
|
return isJSDocSignature(node) ? node.type && node.type.typeExpression && node.type.typeExpression.type : node.type || (isInJSFile(node) ? getJSDocReturnType(node) : void 0);
|
|
}
|
|
function getJSDocTypeParameterDeclarations(node) {
|
|
return flatMap(getJSDocTags(node), (tag) => isNonTypeAliasTemplate(tag) ? tag.typeParameters : void 0);
|
|
}
|
|
function isNonTypeAliasTemplate(tag) {
|
|
return isJSDocTemplateTag(tag) && !(tag.parent.kind === 323 /* JSDoc */ && tag.parent.tags.some(isJSDocTypeAlias));
|
|
}
|
|
function getEffectiveSetAccessorTypeAnnotationNode(node) {
|
|
const parameter = getSetAccessorValueParameter(node);
|
|
return parameter && getEffectiveTypeAnnotationNode(parameter);
|
|
}
|
|
function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) {
|
|
emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments);
|
|
}
|
|
function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) {
|
|
if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos && getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) {
|
|
if (pos !== commentPos && getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) {
|
|
if (comments && comments.length > 0) {
|
|
if (leadingSeparator) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
let emitInterveningSeparator = false;
|
|
for (const comment of comments) {
|
|
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(" ");
|
|
}
|
|
}
|
|
}
|
|
function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) {
|
|
let leadingComments;
|
|
let currentDetachedCommentInfo;
|
|
if (removeComments) {
|
|
if (node.pos === 0) {
|
|
leadingComments = filter(getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal);
|
|
}
|
|
} else {
|
|
leadingComments = getLeadingCommentRanges(text, node.pos);
|
|
}
|
|
if (leadingComments) {
|
|
const detachedComments = [];
|
|
let lastComment;
|
|
for (const comment of leadingComments) {
|
|
if (lastComment) {
|
|
const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end);
|
|
const commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos);
|
|
if (commentLine >= lastCommentLine + 2) {
|
|
break;
|
|
}
|
|
}
|
|
detachedComments.push(comment);
|
|
lastComment = comment;
|
|
}
|
|
if (detachedComments.length) {
|
|
const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, last(detachedComments).end);
|
|
const nodeLine = getLineOfLocalPositionFromLineMap(lineMap, skipTrivia(text, node.pos));
|
|
if (nodeLine >= lastCommentLine + 2) {
|
|
emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments);
|
|
emitComments(text, lineMap, writer, detachedComments, false, true, newLine, writeComment);
|
|
currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: last(detachedComments).end };
|
|
}
|
|
}
|
|
}
|
|
return currentDetachedCommentInfo;
|
|
function isPinnedCommentLocal(comment) {
|
|
return isPinnedComment(text, comment.pos);
|
|
}
|
|
}
|
|
function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) {
|
|
if (text.charCodeAt(commentPos + 1) === 42 /* asterisk */) {
|
|
const firstCommentLineAndCharacter = computeLineAndCharacterOfPosition(lineMap, commentPos);
|
|
const lineCount = lineMap.length;
|
|
let firstCommentLineIndent;
|
|
for (let pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) {
|
|
const nextLineStart = currentLine + 1 === lineCount ? text.length + 1 : lineMap[currentLine + 1];
|
|
if (pos !== commentPos) {
|
|
if (firstCommentLineIndent === void 0) {
|
|
firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos);
|
|
}
|
|
const currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
|
|
const spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart);
|
|
if (spacesToEmit > 0) {
|
|
let numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();
|
|
const indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
|
|
writer.rawWrite(indentSizeSpaceString);
|
|
while (numberOfSingleSpacesToEmit) {
|
|
writer.rawWrite(" ");
|
|
numberOfSingleSpacesToEmit--;
|
|
}
|
|
} else {
|
|
writer.rawWrite("");
|
|
}
|
|
}
|
|
writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart);
|
|
pos = nextLineStart;
|
|
}
|
|
} else {
|
|
writer.writeComment(text.substring(commentPos, commentEnd));
|
|
}
|
|
}
|
|
function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) {
|
|
const end = Math.min(commentEnd, nextLineStart - 1);
|
|
const currentLineText = trimString(text.substring(pos, end));
|
|
if (currentLineText) {
|
|
writer.writeComment(currentLineText);
|
|
if (end !== commentEnd) {
|
|
writer.writeLine();
|
|
}
|
|
} else {
|
|
writer.rawWrite(newLine);
|
|
}
|
|
}
|
|
function calculateIndent(text, pos, end) {
|
|
let currentLineIndent = 0;
|
|
for (; pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) {
|
|
if (text.charCodeAt(pos) === 9 /* tab */) {
|
|
currentLineIndent += getIndentSize() - currentLineIndent % getIndentSize();
|
|
} else {
|
|
currentLineIndent++;
|
|
}
|
|
}
|
|
return currentLineIndent;
|
|
}
|
|
function hasEffectiveModifiers(node) {
|
|
return getEffectiveModifierFlags(node) !== 0 /* None */;
|
|
}
|
|
function hasSyntacticModifiers(node) {
|
|
return getSyntacticModifierFlags(node) !== 0 /* None */;
|
|
}
|
|
function hasEffectiveModifier(node, flags) {
|
|
return !!getSelectedEffectiveModifierFlags(node, flags);
|
|
}
|
|
function hasSyntacticModifier(node, flags) {
|
|
return !!getSelectedSyntacticModifierFlags(node, flags);
|
|
}
|
|
function isStatic(node) {
|
|
return isClassElement(node) && hasStaticModifier(node) || isClassStaticBlockDeclaration(node);
|
|
}
|
|
function hasStaticModifier(node) {
|
|
return hasSyntacticModifier(node, 32 /* Static */);
|
|
}
|
|
function hasOverrideModifier(node) {
|
|
return hasEffectiveModifier(node, 16384 /* Override */);
|
|
}
|
|
function hasAbstractModifier(node) {
|
|
return hasSyntacticModifier(node, 256 /* Abstract */);
|
|
}
|
|
function hasAmbientModifier(node) {
|
|
return hasSyntacticModifier(node, 2 /* Ambient */);
|
|
}
|
|
function hasAccessorModifier(node) {
|
|
return hasSyntacticModifier(node, 128 /* Accessor */);
|
|
}
|
|
function hasEffectiveReadonlyModifier(node) {
|
|
return hasEffectiveModifier(node, 64 /* Readonly */);
|
|
}
|
|
function hasDecorators(node) {
|
|
return hasSyntacticModifier(node, 131072 /* Decorator */);
|
|
}
|
|
function getSelectedEffectiveModifierFlags(node, flags) {
|
|
return getEffectiveModifierFlags(node) & flags;
|
|
}
|
|
function getSelectedSyntacticModifierFlags(node, flags) {
|
|
return getSyntacticModifierFlags(node) & flags;
|
|
}
|
|
function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) {
|
|
if (node.kind >= 0 /* FirstToken */ && node.kind <= 162 /* LastToken */) {
|
|
return 0 /* None */;
|
|
}
|
|
if (!(node.modifierFlagsCache & 536870912 /* HasComputedFlags */)) {
|
|
node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912 /* HasComputedFlags */;
|
|
}
|
|
if (includeJSDoc && !(node.modifierFlagsCache & 4096 /* HasComputedJSDocModifiers */) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) {
|
|
node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096 /* HasComputedJSDocModifiers */;
|
|
}
|
|
return node.modifierFlagsCache & ~(536870912 /* HasComputedFlags */ | 4096 /* HasComputedJSDocModifiers */);
|
|
}
|
|
function getEffectiveModifierFlags(node) {
|
|
return getModifierFlagsWorker(node, true);
|
|
}
|
|
function getSyntacticModifierFlags(node) {
|
|
return getModifierFlagsWorker(node, false);
|
|
}
|
|
function getJSDocModifierFlagsNoCache(node) {
|
|
let flags = 0 /* None */;
|
|
if (!!node.parent && !isParameter(node)) {
|
|
if (isInJSFile(node)) {
|
|
if (getJSDocPublicTagNoCache(node))
|
|
flags |= 4 /* Public */;
|
|
if (getJSDocPrivateTagNoCache(node))
|
|
flags |= 8 /* Private */;
|
|
if (getJSDocProtectedTagNoCache(node))
|
|
flags |= 16 /* Protected */;
|
|
if (getJSDocReadonlyTagNoCache(node))
|
|
flags |= 64 /* Readonly */;
|
|
if (getJSDocOverrideTagNoCache(node))
|
|
flags |= 16384 /* Override */;
|
|
}
|
|
if (getJSDocDeprecatedTagNoCache(node))
|
|
flags |= 8192 /* Deprecated */;
|
|
}
|
|
return flags;
|
|
}
|
|
function getEffectiveModifierFlagsNoCache(node) {
|
|
return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node);
|
|
}
|
|
function getSyntacticModifierFlagsNoCache(node) {
|
|
let flags = canHaveModifiers(node) ? modifiersToFlags(node.modifiers) : 0 /* None */;
|
|
if (node.flags & 4 /* NestedNamespace */ || node.kind === 79 /* Identifier */ && node.isInJSDocNamespace) {
|
|
flags |= 1 /* Export */;
|
|
}
|
|
return flags;
|
|
}
|
|
function modifiersToFlags(modifiers) {
|
|
let flags = 0 /* None */;
|
|
if (modifiers) {
|
|
for (const modifier of modifiers) {
|
|
flags |= modifierToFlag(modifier.kind);
|
|
}
|
|
}
|
|
return flags;
|
|
}
|
|
function modifierToFlag(token) {
|
|
switch (token) {
|
|
case 124 /* StaticKeyword */:
|
|
return 32 /* Static */;
|
|
case 123 /* PublicKeyword */:
|
|
return 4 /* Public */;
|
|
case 122 /* ProtectedKeyword */:
|
|
return 16 /* Protected */;
|
|
case 121 /* PrivateKeyword */:
|
|
return 8 /* Private */;
|
|
case 126 /* AbstractKeyword */:
|
|
return 256 /* Abstract */;
|
|
case 127 /* AccessorKeyword */:
|
|
return 128 /* Accessor */;
|
|
case 93 /* ExportKeyword */:
|
|
return 1 /* Export */;
|
|
case 136 /* DeclareKeyword */:
|
|
return 2 /* Ambient */;
|
|
case 85 /* ConstKeyword */:
|
|
return 2048 /* Const */;
|
|
case 88 /* DefaultKeyword */:
|
|
return 1024 /* Default */;
|
|
case 132 /* AsyncKeyword */:
|
|
return 512 /* Async */;
|
|
case 146 /* ReadonlyKeyword */:
|
|
return 64 /* Readonly */;
|
|
case 161 /* OverrideKeyword */:
|
|
return 16384 /* Override */;
|
|
case 101 /* InKeyword */:
|
|
return 32768 /* In */;
|
|
case 145 /* OutKeyword */:
|
|
return 65536 /* Out */;
|
|
case 167 /* Decorator */:
|
|
return 131072 /* Decorator */;
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function isLogicalOperator(token) {
|
|
return token === 56 /* BarBarToken */ || token === 55 /* AmpersandAmpersandToken */ || token === 53 /* ExclamationToken */;
|
|
}
|
|
function isLogicalOrCoalescingAssignmentOperator(token) {
|
|
return token === 75 /* BarBarEqualsToken */ || token === 76 /* AmpersandAmpersandEqualsToken */ || token === 77 /* QuestionQuestionEqualsToken */;
|
|
}
|
|
function isLogicalOrCoalescingAssignmentExpression(expr) {
|
|
return isLogicalOrCoalescingAssignmentOperator(expr.operatorToken.kind);
|
|
}
|
|
function isAssignmentOperator(token) {
|
|
return token >= 63 /* FirstAssignment */ && token <= 78 /* LastAssignment */;
|
|
}
|
|
function tryGetClassExtendingExpressionWithTypeArguments(node) {
|
|
const cls = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
|
|
return cls && !cls.isImplements ? cls.class : void 0;
|
|
}
|
|
function tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node) {
|
|
return isExpressionWithTypeArguments(node) && isHeritageClause(node.parent) && isClassLike(node.parent.parent) ? { class: node.parent.parent, isImplements: node.parent.token === 117 /* ImplementsKeyword */ } : void 0;
|
|
}
|
|
function isAssignmentExpression(node, excludeCompoundAssignment) {
|
|
return isBinaryExpression(node) && (excludeCompoundAssignment ? node.operatorToken.kind === 63 /* EqualsToken */ : isAssignmentOperator(node.operatorToken.kind)) && isLeftHandSideExpression(node.left);
|
|
}
|
|
function isDestructuringAssignment(node) {
|
|
if (isAssignmentExpression(node, true)) {
|
|
const kind = node.left.kind;
|
|
return kind === 207 /* ObjectLiteralExpression */ || kind === 206 /* ArrayLiteralExpression */;
|
|
}
|
|
return false;
|
|
}
|
|
function isExpressionWithTypeArgumentsInClassExtendsClause(node) {
|
|
return tryGetClassExtendingExpressionWithTypeArguments(node) !== void 0;
|
|
}
|
|
function isEntityNameExpression(node) {
|
|
return node.kind === 79 /* Identifier */ || isPropertyAccessEntityNameExpression(node);
|
|
}
|
|
function getFirstIdentifier(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.left;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
do {
|
|
node = node.expression;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
}
|
|
}
|
|
function isDottedName(node) {
|
|
return node.kind === 79 /* Identifier */ || node.kind === 108 /* ThisKeyword */ || node.kind === 106 /* SuperKeyword */ || node.kind === 233 /* MetaProperty */ || node.kind === 208 /* PropertyAccessExpression */ && isDottedName(node.expression) || node.kind === 214 /* ParenthesizedExpression */ && isDottedName(node.expression);
|
|
}
|
|
function isPropertyAccessEntityNameExpression(node) {
|
|
return isPropertyAccessExpression(node) && isIdentifier(node.name) && isEntityNameExpression(node.expression);
|
|
}
|
|
function tryGetPropertyAccessOrIdentifierToString(expr) {
|
|
if (isPropertyAccessExpression(expr)) {
|
|
const baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (baseStr !== void 0) {
|
|
return baseStr + "." + entityNameToString(expr.name);
|
|
}
|
|
} else if (isElementAccessExpression(expr)) {
|
|
const baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (baseStr !== void 0 && isPropertyName(expr.argumentExpression)) {
|
|
return baseStr + "." + getPropertyNameForPropertyNameNode(expr.argumentExpression);
|
|
}
|
|
} else if (isIdentifier(expr)) {
|
|
return unescapeLeadingUnderscores(expr.escapedText);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isPrototypeAccess(node) {
|
|
return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype";
|
|
}
|
|
function isRightSideOfQualifiedNameOrPropertyAccess(node) {
|
|
return node.parent.kind === 163 /* QualifiedName */ && node.parent.right === node || node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.name === node;
|
|
}
|
|
function isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(node) {
|
|
return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node || isJSDocMemberName(node.parent) && node.parent.right === node;
|
|
}
|
|
function isEmptyObjectLiteral(expression) {
|
|
return expression.kind === 207 /* ObjectLiteralExpression */ && expression.properties.length === 0;
|
|
}
|
|
function isEmptyArrayLiteral(expression) {
|
|
return expression.kind === 206 /* ArrayLiteralExpression */ && expression.elements.length === 0;
|
|
}
|
|
function getLocalSymbolForExportDefault(symbol) {
|
|
if (!isExportDefaultSymbol(symbol) || !symbol.declarations)
|
|
return void 0;
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.localSymbol)
|
|
return decl.localSymbol;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isExportDefaultSymbol(symbol) {
|
|
return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 1024 /* Default */);
|
|
}
|
|
function tryExtractTSExtension(fileName) {
|
|
return find(supportedTSExtensionsForExtractExtension, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function getExpandedCharCodes(input) {
|
|
const output = [];
|
|
const length2 = input.length;
|
|
for (let i = 0; i < length2; i++) {
|
|
const charCode = input.charCodeAt(i);
|
|
if (charCode < 128) {
|
|
output.push(charCode);
|
|
} else if (charCode < 2048) {
|
|
output.push(charCode >> 6 | 192);
|
|
output.push(charCode & 63 | 128);
|
|
} else if (charCode < 65536) {
|
|
output.push(charCode >> 12 | 224);
|
|
output.push(charCode >> 6 & 63 | 128);
|
|
output.push(charCode & 63 | 128);
|
|
} else if (charCode < 131072) {
|
|
output.push(charCode >> 18 | 240);
|
|
output.push(charCode >> 12 & 63 | 128);
|
|
output.push(charCode >> 6 & 63 | 128);
|
|
output.push(charCode & 63 | 128);
|
|
} else {
|
|
Debug.assert(false, "Unexpected code point");
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
|
|
function convertToBase64(input) {
|
|
let result = "";
|
|
const charCodes = getExpandedCharCodes(input);
|
|
let i = 0;
|
|
const length2 = charCodes.length;
|
|
let byte1, byte2, byte3, byte4;
|
|
while (i < length2) {
|
|
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;
|
|
if (i + 1 >= length2) {
|
|
byte3 = byte4 = 64;
|
|
} else if (i + 2 >= length2) {
|
|
byte4 = 64;
|
|
}
|
|
result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4);
|
|
i += 3;
|
|
}
|
|
return result;
|
|
}
|
|
function base64encode(host, input) {
|
|
if (host && host.base64encode) {
|
|
return host.base64encode(input);
|
|
}
|
|
return convertToBase64(input);
|
|
}
|
|
function readJsonOrUndefined(path, hostOrText) {
|
|
const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path);
|
|
if (!jsonText)
|
|
return void 0;
|
|
const result = parseConfigFileTextToJson(path, jsonText);
|
|
return !result.error ? result.config : void 0;
|
|
}
|
|
function readJson(path, host) {
|
|
return readJsonOrUndefined(path, host) || {};
|
|
}
|
|
function directoryProbablyExists(directoryName, host) {
|
|
return !host.directoryExists || host.directoryExists(directoryName);
|
|
}
|
|
var carriageReturnLineFeed = "\r\n";
|
|
var lineFeed = "\n";
|
|
function getNewLineCharacter(options, getNewLine) {
|
|
switch (options.newLine) {
|
|
case 0 /* CarriageReturnLineFeed */:
|
|
return carriageReturnLineFeed;
|
|
case 1 /* LineFeed */:
|
|
return lineFeed;
|
|
}
|
|
return getNewLine ? getNewLine() : sys ? sys.newLine : carriageReturnLineFeed;
|
|
}
|
|
function createRange(pos, end = pos) {
|
|
Debug.assert(end >= pos || end === -1);
|
|
return { pos, end };
|
|
}
|
|
function moveRangeEnd(range, end) {
|
|
return createRange(range.pos, end);
|
|
}
|
|
function moveRangePos(range, pos) {
|
|
return createRange(pos, range.end);
|
|
}
|
|
function moveRangePastDecorators(node) {
|
|
const lastDecorator = canHaveModifiers(node) ? findLast(node.modifiers, isDecorator) : void 0;
|
|
return lastDecorator && !positionIsSynthesized(lastDecorator.end) ? moveRangePos(node, lastDecorator.end) : node;
|
|
}
|
|
function moveRangePastModifiers(node) {
|
|
const lastModifier = canHaveModifiers(node) ? lastOrUndefined(node.modifiers) : void 0;
|
|
return lastModifier && !positionIsSynthesized(lastModifier.end) ? moveRangePos(node, lastModifier.end) : moveRangePastDecorators(node);
|
|
}
|
|
function createTokenRange(pos, token) {
|
|
return createRange(pos, pos + tokenToString(token).length);
|
|
}
|
|
function rangeIsOnSingleLine(range, sourceFile) {
|
|
return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile);
|
|
}
|
|
function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(
|
|
getStartPositionOfRange(range1, sourceFile, false),
|
|
getStartPositionOfRange(range2, sourceFile, false),
|
|
sourceFile
|
|
);
|
|
}
|
|
function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(range1.end, range2.end, sourceFile);
|
|
}
|
|
function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, false), range2.end, sourceFile);
|
|
}
|
|
function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile, false), sourceFile);
|
|
}
|
|
function getLinesBetweenRangeEndAndRangeStart(range1, range2, sourceFile, includeSecondRangeComments) {
|
|
const range2Start = getStartPositionOfRange(range2, sourceFile, includeSecondRangeComments);
|
|
return getLinesBetweenPositions(sourceFile, range1.end, range2Start);
|
|
}
|
|
function positionsAreOnSameLine(pos1, pos2, sourceFile) {
|
|
return getLinesBetweenPositions(sourceFile, pos1, pos2) === 0;
|
|
}
|
|
function getStartPositionOfRange(range, sourceFile, includeComments) {
|
|
return positionIsSynthesized(range.pos) ? -1 : skipTrivia(sourceFile.text, range.pos, false, includeComments);
|
|
}
|
|
function getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
|
|
const startPos = skipTrivia(sourceFile.text, pos, false, includeComments);
|
|
const prevPos = getPreviousNonWhitespacePosition(startPos, stopPos, sourceFile);
|
|
return getLinesBetweenPositions(sourceFile, prevPos != null ? prevPos : stopPos, startPos);
|
|
}
|
|
function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
|
|
const nextPos = skipTrivia(sourceFile.text, pos, false, includeComments);
|
|
return getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos));
|
|
}
|
|
function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) {
|
|
while (pos-- > stopPos) {
|
|
if (!isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) {
|
|
return pos;
|
|
}
|
|
}
|
|
}
|
|
function isDeclarationNameOfEnumOrNamespace(node) {
|
|
const parseNode = getParseTreeNode(node);
|
|
if (parseNode) {
|
|
switch (parseNode.parent.kind) {
|
|
case 263 /* EnumDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return parseNode === parseNode.parent.name;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getInitializedVariables(node) {
|
|
return filter(node.declarations, isInitializedVariable);
|
|
}
|
|
function isInitializedVariable(node) {
|
|
return node.initializer !== void 0;
|
|
}
|
|
function isWatchSet(options) {
|
|
return options.watch && hasProperty(options, "watch");
|
|
}
|
|
function closeFileWatcher(watcher) {
|
|
watcher.close();
|
|
}
|
|
function getCheckFlags(symbol) {
|
|
return symbol.flags & 33554432 /* Transient */ ? symbol.checkFlags : 0;
|
|
}
|
|
function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
|
|
if (s.valueDeclaration) {
|
|
const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
|
|
const flags = getCombinedModifierFlags(declaration);
|
|
return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
|
|
}
|
|
if (getCheckFlags(s) & 6 /* Synthetic */) {
|
|
const checkFlags = s.checkFlags;
|
|
const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 8 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 4 /* Public */ : 16 /* Protected */;
|
|
const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 32 /* Static */ : 0;
|
|
return accessModifier | staticModifier;
|
|
}
|
|
if (s.flags & 4194304 /* Prototype */) {
|
|
return 4 /* Public */ | 32 /* Static */;
|
|
}
|
|
return 0;
|
|
}
|
|
function getCombinedLocalAndExportSymbolFlags(symbol) {
|
|
return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
|
|
}
|
|
function isWriteOnlyAccess(node) {
|
|
return accessKind(node) === AccessKind.Write;
|
|
}
|
|
function isWriteAccess(node) {
|
|
return accessKind(node) !== AccessKind.Read;
|
|
}
|
|
var AccessKind = /* @__PURE__ */ ((AccessKind2) => {
|
|
AccessKind2[AccessKind2["Read"] = 0] = "Read";
|
|
AccessKind2[AccessKind2["Write"] = 1] = "Write";
|
|
AccessKind2[AccessKind2["ReadWrite"] = 2] = "ReadWrite";
|
|
return AccessKind2;
|
|
})(AccessKind || {});
|
|
function accessKind(node) {
|
|
const { parent } = node;
|
|
if (!parent)
|
|
return 0 /* Read */;
|
|
switch (parent.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return accessKind(parent);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const { operator } = parent;
|
|
return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? writeOrReadWrite() : 0 /* Read */;
|
|
case 223 /* BinaryExpression */:
|
|
const { left, operatorToken } = parent;
|
|
return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : writeOrReadWrite() : 0 /* Read */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return parent.name !== node ? 0 /* Read */ : accessKind(parent);
|
|
case 299 /* PropertyAssignment */: {
|
|
const parentAccess = accessKind(parent.parent);
|
|
return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess;
|
|
}
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return node === parent.objectAssignmentInitializer ? 0 /* Read */ : accessKind(parent.parent);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return accessKind(parent);
|
|
default:
|
|
return 0 /* Read */;
|
|
}
|
|
function writeOrReadWrite() {
|
|
return parent.parent && walkUpParenthesizedExpressions(parent.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
|
|
}
|
|
}
|
|
function reverseAccessKind(a) {
|
|
switch (a) {
|
|
case 0 /* Read */:
|
|
return 1 /* Write */;
|
|
case 1 /* Write */:
|
|
return 0 /* Read */;
|
|
case 2 /* ReadWrite */:
|
|
return 2 /* ReadWrite */;
|
|
default:
|
|
return Debug.assertNever(a);
|
|
}
|
|
}
|
|
function compareDataObjects(dst, src) {
|
|
if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) {
|
|
return false;
|
|
}
|
|
for (const 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;
|
|
}
|
|
function clearMap(map2, onDeleteValue) {
|
|
map2.forEach(onDeleteValue);
|
|
map2.clear();
|
|
}
|
|
function mutateMapSkippingNewValues(map2, newMap, options) {
|
|
const { onDeleteValue, onExistingValue } = options;
|
|
map2.forEach((existingValue, key) => {
|
|
const valueInNewMap = newMap.get(key);
|
|
if (valueInNewMap === void 0) {
|
|
map2.delete(key);
|
|
onDeleteValue(existingValue, key);
|
|
} else if (onExistingValue) {
|
|
onExistingValue(existingValue, valueInNewMap, key);
|
|
}
|
|
});
|
|
}
|
|
function mutateMap(map2, newMap, options) {
|
|
mutateMapSkippingNewValues(map2, newMap, options);
|
|
const { createNewValue } = options;
|
|
newMap.forEach((valueInNewMap, key) => {
|
|
if (!map2.has(key)) {
|
|
map2.set(key, createNewValue(key, valueInNewMap));
|
|
}
|
|
});
|
|
}
|
|
function getClassLikeDeclarationOfSymbol(symbol) {
|
|
var _a2;
|
|
return (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
|
|
}
|
|
function getObjectFlags(type) {
|
|
return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
|
|
}
|
|
function typeHasCallOrConstructSignatures(type, checker) {
|
|
return checker.getSignaturesOfType(type, 0 /* Call */).length !== 0 || checker.getSignaturesOfType(type, 1 /* Construct */).length !== 0;
|
|
}
|
|
function isUMDExportSymbol(symbol) {
|
|
return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]);
|
|
}
|
|
function getLastChild(node) {
|
|
let lastChild;
|
|
forEachChild(
|
|
node,
|
|
(child) => {
|
|
if (nodeIsPresent(child))
|
|
lastChild = child;
|
|
},
|
|
(children) => {
|
|
for (let i = children.length - 1; i >= 0; i--) {
|
|
if (nodeIsPresent(children[i])) {
|
|
lastChild = children[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
);
|
|
return lastChild;
|
|
}
|
|
function isTypeNodeKind(kind) {
|
|
return kind >= 179 /* FirstTypeNode */ && kind <= 202 /* LastTypeNode */ || kind === 131 /* AnyKeyword */ || kind === 157 /* UnknownKeyword */ || kind === 148 /* NumberKeyword */ || kind === 160 /* BigIntKeyword */ || kind === 149 /* ObjectKeyword */ || kind === 134 /* BooleanKeyword */ || kind === 152 /* StringKeyword */ || kind === 153 /* SymbolKeyword */ || kind === 114 /* VoidKeyword */ || kind === 155 /* UndefinedKeyword */ || kind === 144 /* NeverKeyword */ || kind === 230 /* ExpressionWithTypeArguments */ || kind === 315 /* JSDocAllType */ || kind === 316 /* JSDocUnknownType */ || kind === 317 /* JSDocNullableType */ || kind === 318 /* JSDocNonNullableType */ || kind === 319 /* JSDocOptionalType */ || kind === 320 /* JSDocFunctionType */ || kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
function isAccessExpression(node) {
|
|
return node.kind === 208 /* PropertyAccessExpression */ || node.kind === 209 /* ElementAccessExpression */;
|
|
}
|
|
function isBundleFileTextLike(section) {
|
|
switch (section.kind) {
|
|
case "text" /* Text */:
|
|
case "internal" /* Internal */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getLeftmostAccessExpression(expr) {
|
|
while (isAccessExpression(expr)) {
|
|
expr = expr.expression;
|
|
}
|
|
return expr;
|
|
}
|
|
function getLeftmostExpression(node, stopAtCallExpressions) {
|
|
while (true) {
|
|
switch (node.kind) {
|
|
case 222 /* PostfixUnaryExpression */:
|
|
node = node.operand;
|
|
continue;
|
|
case 223 /* BinaryExpression */:
|
|
node = node.left;
|
|
continue;
|
|
case 224 /* ConditionalExpression */:
|
|
node = node.condition;
|
|
continue;
|
|
case 212 /* TaggedTemplateExpression */:
|
|
node = node.tag;
|
|
continue;
|
|
case 210 /* CallExpression */:
|
|
if (stopAtCallExpressions) {
|
|
return node;
|
|
}
|
|
case 231 /* AsExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
node = node.expression;
|
|
continue;
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function Symbol4(flags, name) {
|
|
this.flags = flags;
|
|
this.escapedName = name;
|
|
this.declarations = void 0;
|
|
this.valueDeclaration = void 0;
|
|
this.id = void 0;
|
|
this.mergeId = void 0;
|
|
this.parent = void 0;
|
|
}
|
|
function Type3(checker, flags) {
|
|
this.flags = flags;
|
|
if (Debug.isDebugging || tracing) {
|
|
this.checker = checker;
|
|
}
|
|
}
|
|
function Signature2(checker, flags) {
|
|
this.flags = flags;
|
|
if (Debug.isDebugging) {
|
|
this.checker = checker;
|
|
}
|
|
}
|
|
function Node4(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.modifierFlagsCache = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
this.original = void 0;
|
|
}
|
|
function Token(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
}
|
|
function Identifier2(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
this.original = void 0;
|
|
this.flowNode = void 0;
|
|
}
|
|
function SourceMapSource(fileName, text, skipTrivia2) {
|
|
this.fileName = fileName;
|
|
this.text = text;
|
|
this.skipTrivia = skipTrivia2 || ((pos) => pos);
|
|
}
|
|
var objectAllocator = {
|
|
getNodeConstructor: () => Node4,
|
|
getTokenConstructor: () => Token,
|
|
getIdentifierConstructor: () => Identifier2,
|
|
getPrivateIdentifierConstructor: () => Node4,
|
|
getSourceFileConstructor: () => Node4,
|
|
getSymbolConstructor: () => Symbol4,
|
|
getTypeConstructor: () => Type3,
|
|
getSignatureConstructor: () => Signature2,
|
|
getSourceMapSourceConstructor: () => SourceMapSource
|
|
};
|
|
function formatStringFromArgs(text, args, baseIndex = 0) {
|
|
return text.replace(/{(\d+)}/g, (_match, index) => "" + Debug.checkDefined(args[+index + baseIndex]));
|
|
}
|
|
var localizedDiagnosticMessages;
|
|
function setLocalizedDiagnosticMessages(messages) {
|
|
localizedDiagnosticMessages = messages;
|
|
}
|
|
function getLocaleSpecificMessage(message) {
|
|
return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
|
|
}
|
|
function createDetachedDiagnostic(fileName, start, length2, message) {
|
|
assertDiagnosticLocation(void 0, start, length2);
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 4) {
|
|
text = formatStringFromArgs(text, arguments, 4);
|
|
}
|
|
return {
|
|
file: void 0,
|
|
start,
|
|
length: length2,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
fileName
|
|
};
|
|
}
|
|
function isDiagnosticWithDetachedLocation(diagnostic) {
|
|
return diagnostic.file === void 0 && diagnostic.start !== void 0 && diagnostic.length !== void 0 && typeof diagnostic.fileName === "string";
|
|
}
|
|
function attachFileToDiagnostic(diagnostic, file) {
|
|
const fileName = file.fileName || "";
|
|
const length2 = file.text.length;
|
|
Debug.assertEqual(diagnostic.fileName, fileName);
|
|
Debug.assertLessThanOrEqual(diagnostic.start, length2);
|
|
Debug.assertLessThanOrEqual(diagnostic.start + diagnostic.length, length2);
|
|
const diagnosticWithLocation = {
|
|
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 (const related of diagnostic.relatedInformation) {
|
|
if (isDiagnosticWithDetachedLocation(related) && related.fileName === fileName) {
|
|
Debug.assertLessThanOrEqual(related.start, length2);
|
|
Debug.assertLessThanOrEqual(related.start + related.length, length2);
|
|
diagnosticWithLocation.relatedInformation.push(attachFileToDiagnostic(related, file));
|
|
} else {
|
|
diagnosticWithLocation.relatedInformation.push(related);
|
|
}
|
|
}
|
|
}
|
|
return diagnosticWithLocation;
|
|
}
|
|
function attachFileToDiagnostics(diagnostics, file) {
|
|
const diagnosticsWithLocation = [];
|
|
for (const diagnostic of diagnostics) {
|
|
diagnosticsWithLocation.push(attachFileToDiagnostic(diagnostic, file));
|
|
}
|
|
return diagnosticsWithLocation;
|
|
}
|
|
function createFileDiagnostic(file, start, length2, message) {
|
|
assertDiagnosticLocation(file, start, length2);
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 4) {
|
|
text = formatStringFromArgs(text, arguments, 4);
|
|
}
|
|
return {
|
|
file,
|
|
start,
|
|
length: length2,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
reportsDeprecated: message.reportsDeprecated
|
|
};
|
|
}
|
|
function formatMessage(_dummy, message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 2) {
|
|
text = formatStringFromArgs(text, arguments, 2);
|
|
}
|
|
return text;
|
|
}
|
|
function createCompilerDiagnostic(message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 1) {
|
|
text = formatStringFromArgs(text, arguments, 1);
|
|
}
|
|
return {
|
|
file: void 0,
|
|
start: void 0,
|
|
length: void 0,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
reportsDeprecated: message.reportsDeprecated
|
|
};
|
|
}
|
|
function createCompilerDiagnosticFromMessageChain(chain, relatedInformation) {
|
|
return {
|
|
file: void 0,
|
|
start: void 0,
|
|
length: void 0,
|
|
code: chain.code,
|
|
category: chain.category,
|
|
messageText: chain.next ? chain : chain.messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
function chainDiagnosticMessages(details, message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 2) {
|
|
text = formatStringFromArgs(text, arguments, 2);
|
|
}
|
|
return {
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
next: details === void 0 || Array.isArray(details) ? details : [details]
|
|
};
|
|
}
|
|
function concatenateDiagnosticMessageChains(headChain, tailChain) {
|
|
let lastChain = headChain;
|
|
while (lastChain.next) {
|
|
lastChain = lastChain.next[0];
|
|
}
|
|
lastChain.next = [tailChain];
|
|
}
|
|
function getDiagnosticFilePath(diagnostic) {
|
|
return diagnostic.file ? diagnostic.file.path : void 0;
|
|
}
|
|
function compareDiagnostics(d1, d2) {
|
|
return compareDiagnosticsSkipRelatedInformation(d1, d2) || compareRelatedInformation(d1, d2) || 0 /* EqualTo */;
|
|
}
|
|
function compareDiagnosticsSkipRelatedInformation(d1, d2) {
|
|
return compareStringsCaseSensitive(getDiagnosticFilePath(d1), getDiagnosticFilePath(d2)) || compareValues(d1.start, d2.start) || compareValues(d1.length, d2.length) || compareValues(d1.code, d2.code) || compareMessageText(d1.messageText, d2.messageText) || 0 /* EqualTo */;
|
|
}
|
|
function compareRelatedInformation(d1, d2) {
|
|
if (!d1.relatedInformation && !d2.relatedInformation) {
|
|
return 0 /* EqualTo */;
|
|
}
|
|
if (d1.relatedInformation && d2.relatedInformation) {
|
|
return compareValues(d1.relatedInformation.length, d2.relatedInformation.length) || forEach(d1.relatedInformation, (d1i, index) => {
|
|
const d2i = d2.relatedInformation[index];
|
|
return compareDiagnostics(d1i, d2i);
|
|
}) || 0 /* EqualTo */;
|
|
}
|
|
return d1.relatedInformation ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
}
|
|
function compareMessageText(t1, t2) {
|
|
if (typeof t1 === "string" && typeof t2 === "string") {
|
|
return compareStringsCaseSensitive(t1, t2);
|
|
} else if (typeof t1 === "string") {
|
|
return -1 /* LessThan */;
|
|
} else if (typeof t2 === "string") {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
let res = compareStringsCaseSensitive(t1.messageText, t2.messageText);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
if (!t1.next && !t2.next) {
|
|
return 0 /* EqualTo */;
|
|
}
|
|
if (!t1.next) {
|
|
return -1 /* LessThan */;
|
|
}
|
|
if (!t2.next) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
const len = Math.min(t1.next.length, t2.next.length);
|
|
for (let 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 /* LessThan */;
|
|
} else if (t1.next.length > t2.next.length) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
return 0 /* EqualTo */;
|
|
}
|
|
function getLanguageVariant(scriptKind) {
|
|
return scriptKind === 4 /* TSX */ || scriptKind === 2 /* JSX */ || scriptKind === 1 /* JS */ || scriptKind === 6 /* JSON */ ? 1 /* JSX */ : 0 /* Standard */;
|
|
}
|
|
function walkTreeForJSXTags(node) {
|
|
if (!(node.transformFlags & 2 /* ContainsJsx */))
|
|
return void 0;
|
|
return isJsxOpeningLikeElement(node) || isJsxFragment(node) ? node : forEachChild(node, walkTreeForJSXTags);
|
|
}
|
|
function isFileModuleFromUsingJSXTag(file) {
|
|
return !file.isDeclarationFile ? walkTreeForJSXTags(file) : void 0;
|
|
}
|
|
function isFileForcedToBeModuleByFormat(file) {
|
|
return (file.impliedNodeFormat === 99 /* ESNext */ || fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */])) && !file.isDeclarationFile ? true : void 0;
|
|
}
|
|
function getSetExternalModuleIndicator(options) {
|
|
switch (getEmitModuleDetectionKind(options)) {
|
|
case 3 /* Force */:
|
|
return (file) => {
|
|
file.externalModuleIndicator = isFileProbablyExternalModule(file) || !file.isDeclarationFile || void 0;
|
|
};
|
|
case 1 /* Legacy */:
|
|
return (file) => {
|
|
file.externalModuleIndicator = isFileProbablyExternalModule(file);
|
|
};
|
|
case 2 /* Auto */:
|
|
const checks = [isFileProbablyExternalModule];
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
checks.push(isFileModuleFromUsingJSXTag);
|
|
}
|
|
checks.push(isFileForcedToBeModuleByFormat);
|
|
const combined = or(...checks);
|
|
const callback = (file) => void (file.externalModuleIndicator = combined(file));
|
|
return callback;
|
|
}
|
|
}
|
|
function getEmitScriptTarget(compilerOptions) {
|
|
return compilerOptions.target || compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 0 /* ES3 */;
|
|
}
|
|
function getEmitModuleKind(compilerOptions) {
|
|
return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
|
|
}
|
|
function getEmitModuleResolutionKind(compilerOptions) {
|
|
let moduleResolution = compilerOptions.moduleResolution;
|
|
if (moduleResolution === void 0) {
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 1 /* CommonJS */:
|
|
moduleResolution = 2 /* NodeJs */;
|
|
break;
|
|
case 100 /* Node16 */:
|
|
moduleResolution = 3 /* Node16 */;
|
|
break;
|
|
case 199 /* NodeNext */:
|
|
moduleResolution = 99 /* NodeNext */;
|
|
break;
|
|
default:
|
|
moduleResolution = 1 /* Classic */;
|
|
break;
|
|
}
|
|
}
|
|
return moduleResolution;
|
|
}
|
|
function getEmitModuleDetectionKind(options) {
|
|
return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
|
|
}
|
|
function hasJsonModuleEmitEnabled(options) {
|
|
switch (getEmitModuleKind(options)) {
|
|
case 1 /* CommonJS */:
|
|
case 2 /* AMD */:
|
|
case 5 /* ES2015 */:
|
|
case 6 /* ES2020 */:
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function unreachableCodeIsError(options) {
|
|
return options.allowUnreachableCode === false;
|
|
}
|
|
function unusedLabelIsError(options) {
|
|
return options.allowUnusedLabels === false;
|
|
}
|
|
function getAreDeclarationMapsEnabled(options) {
|
|
return !!(getEmitDeclarations(options) && options.declarationMap);
|
|
}
|
|
function getESModuleInterop(compilerOptions) {
|
|
if (compilerOptions.esModuleInterop !== void 0) {
|
|
return compilerOptions.esModuleInterop;
|
|
}
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return true;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAllowSyntheticDefaultImports(compilerOptions) {
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
return compilerOptions.allowSyntheticDefaultImports !== void 0 ? compilerOptions.allowSyntheticDefaultImports : getESModuleInterop(compilerOptions) || moduleKind === 4 /* System */;
|
|
}
|
|
function getEmitDeclarations(compilerOptions) {
|
|
return !!(compilerOptions.declaration || compilerOptions.composite);
|
|
}
|
|
function shouldPreserveConstEnums(compilerOptions) {
|
|
return !!(compilerOptions.preserveConstEnums || compilerOptions.isolatedModules);
|
|
}
|
|
function isIncrementalCompilation(options) {
|
|
return !!(options.incremental || options.composite);
|
|
}
|
|
function getStrictOptionValue(compilerOptions, flag) {
|
|
return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
|
|
}
|
|
function getAllowJSCompilerOption(compilerOptions) {
|
|
return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
|
|
}
|
|
function getUseDefineForClassFields(compilerOptions) {
|
|
return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
|
|
}
|
|
function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, semanticDiagnosticsOptionDeclarations);
|
|
}
|
|
function compilerOptionsAffectEmit(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, affectsEmitOptionDeclarations);
|
|
}
|
|
function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
|
|
}
|
|
function getCompilerOptionValue(options, option) {
|
|
return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
|
|
}
|
|
function getJSXTransformEnabled(options) {
|
|
const jsx = options.jsx;
|
|
return jsx === 2 /* React */ || jsx === 4 /* ReactJSX */ || jsx === 5 /* ReactJSXDev */;
|
|
}
|
|
function getJSXImplicitImportBase(compilerOptions, file) {
|
|
const jsxImportSourcePragmas = file == null ? void 0 : file.pragmas.get("jsximportsource");
|
|
const jsxImportSourcePragma = isArray(jsxImportSourcePragmas) ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1] : jsxImportSourcePragmas;
|
|
return compilerOptions.jsx === 4 /* ReactJSX */ || compilerOptions.jsx === 5 /* ReactJSXDev */ || compilerOptions.jsxImportSource || jsxImportSourcePragma ? (jsxImportSourcePragma == null ? void 0 : jsxImportSourcePragma.arguments.factory) || compilerOptions.jsxImportSource || "react" : void 0;
|
|
}
|
|
function getJSXRuntimeImport(base, options) {
|
|
return base ? `${base}/${options.jsx === 5 /* ReactJSXDev */ ? "jsx-dev-runtime" : "jsx-runtime"}` : void 0;
|
|
}
|
|
function hasZeroOrOneAsteriskCharacter(str) {
|
|
let seenAsterisk = false;
|
|
for (let i = 0; i < str.length; i++) {
|
|
if (str.charCodeAt(i) === 42 /* asterisk */) {
|
|
if (!seenAsterisk) {
|
|
seenAsterisk = true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createSymlinkCache(cwd, getCanonicalFileName) {
|
|
let symlinkedDirectories;
|
|
let symlinkedDirectoriesByRealpath;
|
|
let symlinkedFiles;
|
|
let hasProcessedResolutions = false;
|
|
return {
|
|
getSymlinkedFiles: () => symlinkedFiles,
|
|
getSymlinkedDirectories: () => symlinkedDirectories,
|
|
getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
|
|
setSymlinkedFile: (path, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path, real),
|
|
setSymlinkedDirectory: (symlink, real) => {
|
|
let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
|
|
if (!containsIgnoredPath(symlinkPath)) {
|
|
symlinkPath = ensureTrailingDirectorySeparator(symlinkPath);
|
|
if (real !== false && !(symlinkedDirectories == null ? void 0 : symlinkedDirectories.has(symlinkPath))) {
|
|
(symlinkedDirectoriesByRealpath || (symlinkedDirectoriesByRealpath = createMultiMap())).add(ensureTrailingDirectorySeparator(real.realPath), symlink);
|
|
}
|
|
(symlinkedDirectories || (symlinkedDirectories = /* @__PURE__ */ new Map())).set(symlinkPath, real);
|
|
}
|
|
},
|
|
setSymlinksFromResolutions(files, typeReferenceDirectives) {
|
|
var _a2;
|
|
Debug.assert(!hasProcessedResolutions);
|
|
hasProcessedResolutions = true;
|
|
for (const file of files) {
|
|
(_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution));
|
|
}
|
|
typeReferenceDirectives == null ? void 0 : typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution));
|
|
},
|
|
hasProcessedResolutions: () => hasProcessedResolutions
|
|
};
|
|
function processResolution(cache, resolution) {
|
|
if (!resolution || !resolution.originalPath || !resolution.resolvedFileName)
|
|
return;
|
|
const { resolvedFileName, originalPath } = resolution;
|
|
cache.setSymlinkedFile(toPath(originalPath, cwd, getCanonicalFileName), resolvedFileName);
|
|
const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedFileName, originalPath, cwd, getCanonicalFileName) || emptyArray;
|
|
if (commonResolved && commonOriginal) {
|
|
cache.setSymlinkedDirectory(
|
|
commonOriginal,
|
|
{ real: commonResolved, realPath: toPath(commonResolved, cwd, getCanonicalFileName) }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) {
|
|
const aParts = getPathComponents(getNormalizedAbsolutePath(a, cwd));
|
|
const bParts = getPathComponents(getNormalizedAbsolutePath(b, cwd));
|
|
let 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 ? [getPathFromPathComponents(aParts), getPathFromPathComponents(bParts)] : void 0;
|
|
}
|
|
function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) {
|
|
return s !== void 0 && (getCanonicalFileName(s) === "node_modules" || startsWith(s, "@"));
|
|
}
|
|
var reservedCharacterPattern = /[^\w\s\/]/g;
|
|
var wildcardCharCodes = [42 /* asterisk */, 63 /* question */];
|
|
var commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"];
|
|
var implicitExcludePathRegexPattern = `(?!(${commonPackageFolders.join("|")})(/|$))`;
|
|
var filesMatcher = {
|
|
singleAsteriskRegexFragment: "([^./]|(\\.(?!min\\.js$))?)*",
|
|
doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var directoriesMatcher = {
|
|
singleAsteriskRegexFragment: "[^/]*",
|
|
doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var excludeMatcher = {
|
|
singleAsteriskRegexFragment: "[^/]*",
|
|
doubleAsteriskRegexFragment: "(/.+?)?",
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var wildcardMatchers = {
|
|
files: filesMatcher,
|
|
directories: directoriesMatcher,
|
|
exclude: excludeMatcher
|
|
};
|
|
function getRegularExpressionForWildcard(specs, basePath, usage) {
|
|
const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
|
|
if (!patterns || !patterns.length) {
|
|
return void 0;
|
|
}
|
|
const pattern = patterns.map((pattern2) => `(${pattern2})`).join("|");
|
|
const terminator = usage === "exclude" ? "($|/)" : "$";
|
|
return `^(${pattern})${terminator}`;
|
|
}
|
|
function getRegularExpressionsForWildcards(specs, basePath, usage) {
|
|
if (specs === void 0 || specs.length === 0) {
|
|
return void 0;
|
|
}
|
|
return flatMap(specs, (spec) => spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]));
|
|
}
|
|
function isImplicitGlob(lastPathComponent) {
|
|
return !/[.*?]/.test(lastPathComponent);
|
|
}
|
|
function getPatternFromSpec(spec, basePath, usage) {
|
|
const pattern = spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]);
|
|
return pattern && `^(${pattern})${usage === "exclude" ? "($|/)" : "$"}`;
|
|
}
|
|
function getSubPatternFromSpec(spec, basePath, usage, { singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter: replaceWildcardCharacter2 }) {
|
|
let subpattern = "";
|
|
let hasWrittenComponent = false;
|
|
const components = getNormalizedPathComponents(spec, basePath);
|
|
const lastComponent = last(components);
|
|
if (usage !== "exclude" && lastComponent === "**") {
|
|
return void 0;
|
|
}
|
|
components[0] = removeTrailingDirectorySeparator(components[0]);
|
|
if (isImplicitGlob(lastComponent)) {
|
|
components.push("**", "*");
|
|
}
|
|
let optionalCount = 0;
|
|
for (let component of components) {
|
|
if (component === "**") {
|
|
subpattern += doubleAsteriskRegexFragment;
|
|
} else {
|
|
if (usage === "directories") {
|
|
subpattern += "(";
|
|
optionalCount++;
|
|
}
|
|
if (hasWrittenComponent) {
|
|
subpattern += directorySeparator;
|
|
}
|
|
if (usage !== "exclude") {
|
|
let componentPattern = "";
|
|
if (component.charCodeAt(0) === 42 /* asterisk */) {
|
|
componentPattern += "([^./]" + singleAsteriskRegexFragment + ")?";
|
|
component = component.substr(1);
|
|
} else if (component.charCodeAt(0) === 63 /* question */) {
|
|
componentPattern += "[^./]";
|
|
component = component.substr(1);
|
|
}
|
|
componentPattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter2);
|
|
if (componentPattern !== component) {
|
|
subpattern += implicitExcludePathRegexPattern;
|
|
}
|
|
subpattern += componentPattern;
|
|
} else {
|
|
subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter2);
|
|
}
|
|
}
|
|
hasWrittenComponent = true;
|
|
}
|
|
while (optionalCount > 0) {
|
|
subpattern += ")?";
|
|
optionalCount--;
|
|
}
|
|
return subpattern;
|
|
}
|
|
function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
|
|
return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
|
|
}
|
|
function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) {
|
|
path = normalizePath(path);
|
|
currentDirectory = normalizePath(currentDirectory);
|
|
const absolutePath = combinePaths(currentDirectory, path);
|
|
return {
|
|
includeFilePatterns: map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), (pattern) => `^${pattern}$`),
|
|
includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
|
|
includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
|
|
excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
|
|
basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
|
|
};
|
|
}
|
|
function getRegexFromPattern(pattern, useCaseSensitiveFileNames) {
|
|
return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
|
|
}
|
|
function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) {
|
|
path = normalizePath(path);
|
|
currentDirectory = normalizePath(currentDirectory);
|
|
const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
|
|
const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, useCaseSensitiveFileNames));
|
|
const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
|
|
const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
|
|
const results = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
|
|
const visited = /* @__PURE__ */ new Map();
|
|
const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
for (const basePath of patterns.basePaths) {
|
|
visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
|
|
}
|
|
return flatten(results);
|
|
function visitDirectory(path2, absolutePath, depth2) {
|
|
const canonicalPath = toCanonical(realpath(absolutePath));
|
|
if (visited.has(canonicalPath))
|
|
return;
|
|
visited.set(canonicalPath, true);
|
|
const { files, directories } = getFileSystemEntries(path2);
|
|
for (const current of sort(files, compareStringsCaseSensitive)) {
|
|
const name = combinePaths(path2, current);
|
|
const absoluteName = combinePaths(absolutePath, current);
|
|
if (extensions && !fileExtensionIsOneOf(name, extensions))
|
|
continue;
|
|
if (excludeRegex && excludeRegex.test(absoluteName))
|
|
continue;
|
|
if (!includeFileRegexes) {
|
|
results[0].push(name);
|
|
} else {
|
|
const includeIndex = findIndex(includeFileRegexes, (re) => re.test(absoluteName));
|
|
if (includeIndex !== -1) {
|
|
results[includeIndex].push(name);
|
|
}
|
|
}
|
|
}
|
|
if (depth2 !== void 0) {
|
|
depth2--;
|
|
if (depth2 === 0) {
|
|
return;
|
|
}
|
|
}
|
|
for (const current of sort(directories, compareStringsCaseSensitive)) {
|
|
const name = combinePaths(path2, current);
|
|
const absoluteName = combinePaths(absolutePath, current);
|
|
if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && (!excludeRegex || !excludeRegex.test(absoluteName))) {
|
|
visitDirectory(name, absoluteName, depth2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getBasePaths(path, includes, useCaseSensitiveFileNames) {
|
|
const basePaths = [path];
|
|
if (includes) {
|
|
const includeBasePaths = [];
|
|
for (const include of includes) {
|
|
const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
|
|
includeBasePaths.push(getIncludeBasePath(absolute));
|
|
}
|
|
includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames));
|
|
for (const includeBasePath of includeBasePaths) {
|
|
if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
|
|
basePaths.push(includeBasePath);
|
|
}
|
|
}
|
|
}
|
|
return basePaths;
|
|
}
|
|
function getIncludeBasePath(absolute) {
|
|
const wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
|
|
if (wildcardOffset < 0) {
|
|
return !hasExtension(absolute) ? absolute : removeTrailingDirectorySeparator(getDirectoryPath(absolute));
|
|
}
|
|
return absolute.substring(0, absolute.lastIndexOf(directorySeparator, wildcardOffset));
|
|
}
|
|
function ensureScriptKind(fileName, scriptKind) {
|
|
return scriptKind || getScriptKindFromFileName(fileName) || 3 /* TS */;
|
|
}
|
|
function getScriptKindFromFileName(fileName) {
|
|
const ext = fileName.substr(fileName.lastIndexOf("."));
|
|
switch (ext.toLowerCase()) {
|
|
case ".js" /* Js */:
|
|
case ".cjs" /* Cjs */:
|
|
case ".mjs" /* Mjs */:
|
|
return 1 /* JS */;
|
|
case ".jsx" /* Jsx */:
|
|
return 2 /* JSX */;
|
|
case ".ts" /* Ts */:
|
|
case ".cts" /* Cts */:
|
|
case ".mts" /* Mts */:
|
|
return 3 /* TS */;
|
|
case ".tsx" /* Tsx */:
|
|
return 4 /* TSX */;
|
|
case ".json" /* Json */:
|
|
return 6 /* JSON */;
|
|
default:
|
|
return 0 /* Unknown */;
|
|
}
|
|
}
|
|
var supportedTSExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */], [".cts" /* Cts */, ".d.cts" /* Dcts */], [".mts" /* Mts */, ".d.mts" /* Dmts */]];
|
|
var supportedTSExtensionsFlat = flatten(supportedTSExtensions);
|
|
var supportedTSExtensionsWithJson = [...supportedTSExtensions, [".json" /* Json */]];
|
|
var supportedTSExtensionsForExtractExtension = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */, ".cts" /* Cts */, ".mts" /* Mts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".cts" /* Cts */, ".mts" /* Mts */];
|
|
var supportedJSExtensions = [[".js" /* Js */, ".jsx" /* Jsx */], [".mjs" /* Mjs */], [".cjs" /* Cjs */]];
|
|
var supportedJSExtensionsFlat = flatten(supportedJSExtensions);
|
|
var allSupportedExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */, ".js" /* Js */, ".jsx" /* Jsx */], [".cts" /* Cts */, ".d.cts" /* Dcts */, ".cjs" /* Cjs */], [".mts" /* Mts */, ".d.mts" /* Dmts */, ".mjs" /* Mjs */]];
|
|
var allSupportedExtensionsWithJson = [...allSupportedExtensions, [".json" /* Json */]];
|
|
var supportedDeclarationExtensions = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */];
|
|
var supportedTSImplementationExtensions = [".ts" /* Ts */, ".cts" /* Cts */, ".mts" /* Mts */, ".tsx" /* Tsx */];
|
|
function getSupportedExtensions(options, extraFileExtensions) {
|
|
const needJsExtensions = options && getAllowJSCompilerOption(options);
|
|
if (!extraFileExtensions || extraFileExtensions.length === 0) {
|
|
return needJsExtensions ? allSupportedExtensions : supportedTSExtensions;
|
|
}
|
|
const builtins = needJsExtensions ? allSupportedExtensions : supportedTSExtensions;
|
|
const flatBuiltins = flatten(builtins);
|
|
const extensions = [
|
|
...builtins,
|
|
...mapDefined(extraFileExtensions, (x) => x.scriptKind === 7 /* Deferred */ || needJsExtensions && isJSLike(x.scriptKind) && flatBuiltins.indexOf(x.extension) === -1 ? [x.extension] : void 0)
|
|
];
|
|
return extensions;
|
|
}
|
|
function getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) {
|
|
if (!options || !options.resolveJsonModule)
|
|
return supportedExtensions;
|
|
if (supportedExtensions === allSupportedExtensions)
|
|
return allSupportedExtensionsWithJson;
|
|
if (supportedExtensions === supportedTSExtensions)
|
|
return supportedTSExtensionsWithJson;
|
|
return [...supportedExtensions, [".json" /* Json */]];
|
|
}
|
|
function isJSLike(scriptKind) {
|
|
return scriptKind === 1 /* JS */ || scriptKind === 2 /* JSX */;
|
|
}
|
|
function hasJSFileExtension(fileName) {
|
|
return some(supportedJSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function hasTSFileExtension(fileName) {
|
|
return some(supportedTSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function isSupportedSourceFileName(fileName, compilerOptions, extraFileExtensions) {
|
|
if (!fileName)
|
|
return false;
|
|
const supportedExtensions = getSupportedExtensions(compilerOptions, extraFileExtensions);
|
|
for (const extension of flatten(getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions))) {
|
|
if (fileExtensionIs(fileName, extension)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function numberOfDirectorySeparators(str) {
|
|
const match = str.match(/\//g);
|
|
return match ? match.length : 0;
|
|
}
|
|
function compareNumberOfDirectorySeparators(path1, path2) {
|
|
return compareValues(
|
|
numberOfDirectorySeparators(path1),
|
|
numberOfDirectorySeparators(path2)
|
|
);
|
|
}
|
|
var extensionsToRemove = [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".mts" /* Mts */, ".cjs" /* Cjs */, ".cts" /* Cts */, ".ts" /* Ts */, ".js" /* Js */, ".tsx" /* Tsx */, ".jsx" /* Jsx */, ".json" /* Json */];
|
|
function removeFileExtension(path) {
|
|
for (const ext of extensionsToRemove) {
|
|
const extensionless = tryRemoveExtension(path, ext);
|
|
if (extensionless !== void 0) {
|
|
return extensionless;
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
function tryRemoveExtension(path, extension) {
|
|
return fileExtensionIs(path, extension) ? removeExtension(path, extension) : void 0;
|
|
}
|
|
function removeExtension(path, extension) {
|
|
return path.substring(0, path.length - extension.length);
|
|
}
|
|
function changeExtension(path, newExtension) {
|
|
return changeAnyExtension(path, newExtension, extensionsToRemove, false);
|
|
}
|
|
function tryParsePattern(pattern) {
|
|
const indexOfStar = pattern.indexOf("*");
|
|
if (indexOfStar === -1) {
|
|
return pattern;
|
|
}
|
|
return pattern.indexOf("*", indexOfStar + 1) !== -1 ? void 0 : {
|
|
prefix: pattern.substr(0, indexOfStar),
|
|
suffix: pattern.substr(indexOfStar + 1)
|
|
};
|
|
}
|
|
function tryParsePatterns(paths) {
|
|
return mapDefined(getOwnKeys(paths), (path) => tryParsePattern(path));
|
|
}
|
|
function positionIsSynthesized(pos) {
|
|
return !(pos >= 0);
|
|
}
|
|
function extensionIsTS(ext) {
|
|
return ext === ".ts" /* Ts */ || ext === ".tsx" /* Tsx */ || ext === ".d.ts" /* Dts */ || ext === ".cts" /* Cts */ || ext === ".mts" /* Mts */ || ext === ".d.mts" /* Dmts */ || ext === ".d.cts" /* Dcts */;
|
|
}
|
|
function resolutionExtensionIsTSOrJson(ext) {
|
|
return extensionIsTS(ext) || ext === ".json" /* Json */;
|
|
}
|
|
function extensionFromPath(path) {
|
|
const ext = tryGetExtensionFromPath2(path);
|
|
return ext !== void 0 ? ext : Debug.fail(`File ${path} has unknown extension.`);
|
|
}
|
|
function tryGetExtensionFromPath2(path) {
|
|
return find(extensionsToRemove, (e) => fileExtensionIs(path, e));
|
|
}
|
|
function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
|
|
return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
|
|
}
|
|
var emptyFileSystemEntries = {
|
|
files: emptyArray,
|
|
directories: emptyArray
|
|
};
|
|
function matchPatternOrExact(patternOrStrings, candidate) {
|
|
const patterns = [];
|
|
for (const patternOrString of patternOrStrings) {
|
|
if (patternOrString === candidate) {
|
|
return candidate;
|
|
}
|
|
if (!isString(patternOrString)) {
|
|
patterns.push(patternOrString);
|
|
}
|
|
}
|
|
return findBestPatternMatch(patterns, (_) => _, candidate);
|
|
}
|
|
function sliceAfter(arr, value) {
|
|
const index = arr.indexOf(value);
|
|
Debug.assert(index !== -1);
|
|
return arr.slice(index);
|
|
}
|
|
function addRelatedInfo(diagnostic, ...relatedInformation) {
|
|
if (!relatedInformation.length) {
|
|
return diagnostic;
|
|
}
|
|
if (!diagnostic.relatedInformation) {
|
|
diagnostic.relatedInformation = [];
|
|
}
|
|
Debug.assert(diagnostic.relatedInformation !== emptyArray, "Diagnostic had empty array singleton for related info, but is still being constructed!");
|
|
diagnostic.relatedInformation.push(...relatedInformation);
|
|
return diagnostic;
|
|
}
|
|
function minAndMax(arr, getValue) {
|
|
Debug.assert(arr.length !== 0);
|
|
let min2 = getValue(arr[0]);
|
|
let max = min2;
|
|
for (let i = 1; i < arr.length; i++) {
|
|
const value = getValue(arr[i]);
|
|
if (value < min2) {
|
|
min2 = value;
|
|
} else if (value > max) {
|
|
max = value;
|
|
}
|
|
}
|
|
return { min: min2, max };
|
|
}
|
|
function rangeOfNode(node) {
|
|
return { pos: getTokenPosOfNode(node), end: node.end };
|
|
}
|
|
function rangeOfTypeParameters(sourceFile, typeParameters) {
|
|
const pos = typeParameters.pos - 1;
|
|
const end = skipTrivia(sourceFile.text, typeParameters.end) + 1;
|
|
return { pos, end };
|
|
}
|
|
function skipTypeChecking(sourceFile, options, host) {
|
|
return options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib || host.isSourceOfProjectReferenceRedirect(sourceFile.fileName);
|
|
}
|
|
function isJsonEqual(a, b) {
|
|
return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && equalOwnProperties(a, b, isJsonEqual);
|
|
}
|
|
function parsePseudoBigInt(stringValue) {
|
|
let log2Base;
|
|
switch (stringValue.charCodeAt(1)) {
|
|
case 98 /* b */:
|
|
case 66 /* B */:
|
|
log2Base = 1;
|
|
break;
|
|
case 111 /* o */:
|
|
case 79 /* O */:
|
|
log2Base = 3;
|
|
break;
|
|
case 120 /* x */:
|
|
case 88 /* X */:
|
|
log2Base = 4;
|
|
break;
|
|
default:
|
|
const nIndex = stringValue.length - 1;
|
|
let nonZeroStart = 0;
|
|
while (stringValue.charCodeAt(nonZeroStart) === 48 /* _0 */) {
|
|
nonZeroStart++;
|
|
}
|
|
return stringValue.slice(nonZeroStart, nIndex) || "0";
|
|
}
|
|
const startIndex = 2, endIndex = stringValue.length - 1;
|
|
const bitsNeeded = (endIndex - startIndex) * log2Base;
|
|
const segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0));
|
|
for (let i = endIndex - 1, bitOffset = 0; i >= startIndex; i--, bitOffset += log2Base) {
|
|
const segment = bitOffset >>> 4;
|
|
const digitChar = stringValue.charCodeAt(i);
|
|
const digit = digitChar <= 57 /* _9 */ ? digitChar - 48 /* _0 */ : 10 + digitChar - (digitChar <= 70 /* F */ ? 65 /* A */ : 97 /* a */);
|
|
const shiftedDigit = digit << (bitOffset & 15);
|
|
segments[segment] |= shiftedDigit;
|
|
const residual = shiftedDigit >>> 16;
|
|
if (residual)
|
|
segments[segment + 1] |= residual;
|
|
}
|
|
let base10Value = "";
|
|
let firstNonzeroSegment = segments.length - 1;
|
|
let segmentsRemaining = true;
|
|
while (segmentsRemaining) {
|
|
let mod10 = 0;
|
|
segmentsRemaining = false;
|
|
for (let segment = firstNonzeroSegment; segment >= 0; segment--) {
|
|
const newSegment = mod10 << 16 | segments[segment];
|
|
const segmentValue = newSegment / 10 | 0;
|
|
segments[segment] = segmentValue;
|
|
mod10 = newSegment - segmentValue * 10;
|
|
if (segmentValue && !segmentsRemaining) {
|
|
firstNonzeroSegment = segment;
|
|
segmentsRemaining = true;
|
|
}
|
|
}
|
|
base10Value = mod10 + base10Value;
|
|
}
|
|
return base10Value;
|
|
}
|
|
function pseudoBigIntToString({ negative, base10Value }) {
|
|
return (negative && base10Value !== "0" ? "-" : "") + base10Value;
|
|
}
|
|
function isValidTypeOnlyAliasUseSite(useSite) {
|
|
return !!(useSite.flags & 16777216 /* Ambient */) || isPartOfTypeQuery(useSite) || isIdentifierInNonEmittingHeritageClause(useSite) || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
|
|
}
|
|
function isShorthandPropertyNameUseSite(useSite) {
|
|
return isIdentifier(useSite) && isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite;
|
|
}
|
|
function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
|
|
while (node.kind === 79 /* Identifier */ || node.kind === 208 /* PropertyAccessExpression */) {
|
|
node = node.parent;
|
|
}
|
|
if (node.kind !== 164 /* ComputedPropertyName */) {
|
|
return false;
|
|
}
|
|
if (hasSyntacticModifier(node.parent, 256 /* Abstract */)) {
|
|
return true;
|
|
}
|
|
const containerKind = node.parent.parent.kind;
|
|
return containerKind === 261 /* InterfaceDeclaration */ || containerKind === 184 /* TypeLiteral */;
|
|
}
|
|
function isIdentifierInNonEmittingHeritageClause(node) {
|
|
if (node.kind !== 79 /* Identifier */)
|
|
return false;
|
|
const heritageClause = findAncestor(node.parent, (parent) => {
|
|
switch (parent.kind) {
|
|
case 294 /* HeritageClause */:
|
|
return true;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return false;
|
|
default:
|
|
return "quit";
|
|
}
|
|
});
|
|
return (heritageClause == null ? void 0 : heritageClause.token) === 117 /* ImplementsKeyword */ || (heritageClause == null ? void 0 : heritageClause.parent.kind) === 261 /* InterfaceDeclaration */;
|
|
}
|
|
function isIdentifierTypeReference(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName);
|
|
}
|
|
function arrayIsHomogeneous(array, comparer = equateValues) {
|
|
if (array.length < 2)
|
|
return true;
|
|
const first2 = array[0];
|
|
for (let i = 1, length2 = array.length; i < length2; i++) {
|
|
const target = array[i];
|
|
if (!comparer(first2, target))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function setTextRangePos(range, pos) {
|
|
range.pos = pos;
|
|
return range;
|
|
}
|
|
function setTextRangeEnd(range, end) {
|
|
range.end = end;
|
|
return range;
|
|
}
|
|
function setTextRangePosEnd(range, pos, end) {
|
|
return setTextRangeEnd(setTextRangePos(range, pos), end);
|
|
}
|
|
function setTextRangePosWidth(range, pos, width) {
|
|
return setTextRangePosEnd(range, pos, pos + width);
|
|
}
|
|
function setNodeFlags(node, newFlags) {
|
|
if (node) {
|
|
node.flags = newFlags;
|
|
}
|
|
return node;
|
|
}
|
|
function setParent(child, parent) {
|
|
if (child && parent) {
|
|
child.parent = parent;
|
|
}
|
|
return child;
|
|
}
|
|
function setEachParent(children, parent) {
|
|
if (children) {
|
|
for (const child of children) {
|
|
setParent(child, parent);
|
|
}
|
|
}
|
|
return children;
|
|
}
|
|
function setParentRecursive(rootNode, incremental) {
|
|
if (!rootNode)
|
|
return rootNode;
|
|
forEachChildRecursively(rootNode, isJSDocNode(rootNode) ? bindParentToChildIgnoringJSDoc : bindParentToChild);
|
|
return rootNode;
|
|
function bindParentToChildIgnoringJSDoc(child, parent) {
|
|
if (incremental && child.parent === parent) {
|
|
return "skip";
|
|
}
|
|
setParent(child, parent);
|
|
}
|
|
function bindJSDoc(child) {
|
|
if (hasJSDocNodes(child)) {
|
|
for (const doc of child.jsDoc) {
|
|
bindParentToChildIgnoringJSDoc(doc, child);
|
|
forEachChildRecursively(doc, bindParentToChildIgnoringJSDoc);
|
|
}
|
|
}
|
|
}
|
|
function bindParentToChild(child, parent) {
|
|
return bindParentToChildIgnoringJSDoc(child, parent) || bindJSDoc(child);
|
|
}
|
|
}
|
|
function isPackedElement(node) {
|
|
return !isOmittedExpression(node);
|
|
}
|
|
function isPackedArrayLiteral(node) {
|
|
return isArrayLiteralExpression(node) && every(node.elements, isPackedElement);
|
|
}
|
|
function expressionResultIsUnused(node) {
|
|
Debug.assertIsDefined(node.parent);
|
|
while (true) {
|
|
const parent = node.parent;
|
|
if (isParenthesizedExpression(parent)) {
|
|
node = parent;
|
|
continue;
|
|
}
|
|
if (isExpressionStatement(parent) || isVoidExpression(parent) || isForStatement(parent) && (parent.initializer === node || parent.incrementor === node)) {
|
|
return true;
|
|
}
|
|
if (isCommaListExpression(parent)) {
|
|
if (node !== last(parent.elements))
|
|
return true;
|
|
node = parent;
|
|
continue;
|
|
}
|
|
if (isBinaryExpression(parent) && parent.operatorToken.kind === 27 /* CommaToken */) {
|
|
if (node === parent.left)
|
|
return true;
|
|
node = parent;
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function containsIgnoredPath(path) {
|
|
return some(ignoredPaths, (p) => stringContains(path, p));
|
|
}
|
|
function getContainingNodeArray(node) {
|
|
if (!node.parent)
|
|
return void 0;
|
|
switch (node.kind) {
|
|
case 165 /* TypeParameter */:
|
|
const { parent: parent2 } = node;
|
|
return parent2.kind === 192 /* InferType */ ? void 0 : parent2.typeParameters;
|
|
case 166 /* Parameter */:
|
|
return node.parent.parameters;
|
|
case 201 /* TemplateLiteralTypeSpan */:
|
|
return node.parent.templateSpans;
|
|
case 236 /* TemplateSpan */:
|
|
return node.parent.templateSpans;
|
|
case 167 /* Decorator */: {
|
|
const { parent: parent3 } = node;
|
|
return canHaveDecorators(parent3) ? parent3.modifiers : canHaveIllegalDecorators(parent3) ? parent3.illegalDecorators : void 0;
|
|
}
|
|
case 294 /* HeritageClause */:
|
|
return node.parent.heritageClauses;
|
|
}
|
|
const { parent } = node;
|
|
if (isJSDocTag(node)) {
|
|
return isJSDocTypeLiteral(node.parent) ? void 0 : node.parent.tags;
|
|
}
|
|
switch (parent.kind) {
|
|
case 184 /* TypeLiteral */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
return isTypeElement(node) ? parent.members : void 0;
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return parent.types;
|
|
case 186 /* TupleType */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 354 /* CommaListExpression */:
|
|
case 272 /* NamedImports */:
|
|
case 276 /* NamedExports */:
|
|
return parent.elements;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 289 /* JsxAttributes */:
|
|
return parent.properties;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return isTypeNode(node) ? parent.typeArguments : parent.expression === node ? void 0 : parent.arguments;
|
|
case 281 /* JsxElement */:
|
|
case 285 /* JsxFragment */:
|
|
return isJsxChild(node) ? parent.children : void 0;
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return isTypeNode(node) ? parent.typeArguments : void 0;
|
|
case 238 /* Block */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 265 /* ModuleBlock */:
|
|
return parent.statements;
|
|
case 266 /* CaseBlock */:
|
|
return parent.clauses;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return isClassElement(node) ? parent.members : void 0;
|
|
case 263 /* EnumDeclaration */:
|
|
return isEnumMember(node) ? parent.members : void 0;
|
|
case 308 /* SourceFile */:
|
|
return parent.statements;
|
|
}
|
|
}
|
|
function hasContextSensitiveParameters(node) {
|
|
if (!node.typeParameters) {
|
|
if (some(node.parameters, (p) => !getEffectiveTypeAnnotationNode(p))) {
|
|
return true;
|
|
}
|
|
if (node.kind !== 216 /* ArrowFunction */) {
|
|
const parameter = firstOrUndefined(node.parameters);
|
|
if (!(parameter && parameterIsThisKeyword(parameter))) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInfinityOrNaNString(name) {
|
|
return name === "Infinity" || name === "-Infinity" || name === "NaN";
|
|
}
|
|
function isCatchClauseVariableDeclaration(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ && node.parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isParameterOrCatchClauseVariable(symbol) {
|
|
const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
|
|
return !!declaration && (isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
|
|
}
|
|
function isFunctionExpressionOrArrowFunction(node) {
|
|
return node.kind === 215 /* FunctionExpression */ || node.kind === 216 /* ArrowFunction */;
|
|
}
|
|
function isNumericLiteralName(name) {
|
|
return (+name).toString() === name;
|
|
}
|
|
function createPropertyNameNodeForIdentifierOrLiteral(name, target, singleQuote, stringNamed) {
|
|
return isIdentifierText(name, target) ? factory.createIdentifier(name) : !stringNamed && isNumericLiteralName(name) && +name >= 0 ? factory.createNumericLiteral(+name) : factory.createStringLiteral(name, !!singleQuote);
|
|
}
|
|
function isThisTypeParameter(type) {
|
|
return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
|
|
}
|
|
function getNodeModulePathParts(fullPath) {
|
|
let topLevelNodeModulesIndex = 0;
|
|
let topLevelPackageNameIndex = 0;
|
|
let packageRootIndex = 0;
|
|
let fileNameIndex = 0;
|
|
let States;
|
|
((States2) => {
|
|
States2[States2["BeforeNodeModules"] = 0] = "BeforeNodeModules";
|
|
States2[States2["NodeModules"] = 1] = "NodeModules";
|
|
States2[States2["Scope"] = 2] = "Scope";
|
|
States2[States2["PackageContent"] = 3] = "PackageContent";
|
|
})(States || (States = {}));
|
|
let partStart = 0;
|
|
let partEnd = 0;
|
|
let state = 0 /* BeforeNodeModules */;
|
|
while (partEnd >= 0) {
|
|
partStart = partEnd;
|
|
partEnd = fullPath.indexOf("/", partStart + 1);
|
|
switch (state) {
|
|
case 0 /* BeforeNodeModules */:
|
|
if (fullPath.indexOf(nodeModulesPathPart, partStart) === partStart) {
|
|
topLevelNodeModulesIndex = partStart;
|
|
topLevelPackageNameIndex = partEnd;
|
|
state = 1 /* NodeModules */;
|
|
}
|
|
break;
|
|
case 1 /* NodeModules */:
|
|
case 2 /* Scope */:
|
|
if (state === 1 /* NodeModules */ && fullPath.charAt(partStart + 1) === "@") {
|
|
state = 2 /* Scope */;
|
|
} else {
|
|
packageRootIndex = partEnd;
|
|
state = 3 /* PackageContent */;
|
|
}
|
|
break;
|
|
case 3 /* PackageContent */:
|
|
if (fullPath.indexOf(nodeModulesPathPart, partStart) === partStart) {
|
|
state = 1 /* NodeModules */;
|
|
} else {
|
|
state = 3 /* PackageContent */;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
fileNameIndex = partStart;
|
|
return state > 1 /* NodeModules */ ? { topLevelNodeModulesIndex, topLevelPackageNameIndex, packageRootIndex, fileNameIndex } : void 0;
|
|
}
|
|
function isTypeDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 165 /* TypeParameter */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return true;
|
|
case 270 /* ImportClause */:
|
|
return node.isTypeOnly;
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return node.parent.parent.isTypeOnly;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function canHaveExportModifier(node) {
|
|
return isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isTypeDeclaration(node) || isModuleDeclaration(node) && !isExternalModuleAugmentation(node) && !isGlobalScopeAugmentation(node);
|
|
}
|
|
function isOptionalJSDocPropertyLikeTag(node) {
|
|
if (!isJSDocPropertyLikeTag(node)) {
|
|
return false;
|
|
}
|
|
const { isBracketed, typeExpression } = node;
|
|
return isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* JSDocOptionalType */;
|
|
}
|
|
|
|
// src/compiler/factory/baseNodeFactory.ts
|
|
function createBaseNodeFactory() {
|
|
let NodeConstructor2;
|
|
let TokenConstructor2;
|
|
let IdentifierConstructor2;
|
|
let PrivateIdentifierConstructor2;
|
|
let SourceFileConstructor2;
|
|
return {
|
|
createBaseSourceFileNode,
|
|
createBaseIdentifierNode,
|
|
createBasePrivateIdentifierNode,
|
|
createBaseTokenNode,
|
|
createBaseNode
|
|
};
|
|
function createBaseSourceFileNode(kind) {
|
|
return new (SourceFileConstructor2 || (SourceFileConstructor2 = objectAllocator.getSourceFileConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseIdentifierNode(kind) {
|
|
return new (IdentifierConstructor2 || (IdentifierConstructor2 = objectAllocator.getIdentifierConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBasePrivateIdentifierNode(kind) {
|
|
return new (PrivateIdentifierConstructor2 || (PrivateIdentifierConstructor2 = objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseTokenNode(kind) {
|
|
return new (TokenConstructor2 || (TokenConstructor2 = objectAllocator.getTokenConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseNode(kind) {
|
|
return new (NodeConstructor2 || (NodeConstructor2 = objectAllocator.getNodeConstructor()))(kind, -1, -1);
|
|
}
|
|
}
|
|
|
|
// src/compiler/factory/parenthesizerRules.ts
|
|
function createParenthesizerRules(factory2) {
|
|
let binaryLeftOperandParenthesizerCache;
|
|
let binaryRightOperandParenthesizerCache;
|
|
return {
|
|
getParenthesizeLeftSideOfBinaryForOperator,
|
|
getParenthesizeRightSideOfBinaryForOperator,
|
|
parenthesizeLeftSideOfBinary,
|
|
parenthesizeRightSideOfBinary,
|
|
parenthesizeExpressionOfComputedPropertyName,
|
|
parenthesizeConditionOfConditionalExpression,
|
|
parenthesizeBranchOfConditionalExpression,
|
|
parenthesizeExpressionOfExportDefault,
|
|
parenthesizeExpressionOfNew,
|
|
parenthesizeLeftSideOfAccess,
|
|
parenthesizeOperandOfPostfixUnary,
|
|
parenthesizeOperandOfPrefixUnary,
|
|
parenthesizeExpressionsOfCommaDelimitedList,
|
|
parenthesizeExpressionForDisallowedComma,
|
|
parenthesizeExpressionOfExpressionStatement,
|
|
parenthesizeConciseBodyOfArrowFunction,
|
|
parenthesizeCheckTypeOfConditionalType,
|
|
parenthesizeExtendsTypeOfConditionalType,
|
|
parenthesizeConstituentTypesOfUnionType,
|
|
parenthesizeConstituentTypeOfUnionType,
|
|
parenthesizeConstituentTypesOfIntersectionType,
|
|
parenthesizeConstituentTypeOfIntersectionType,
|
|
parenthesizeOperandOfTypeOperator,
|
|
parenthesizeOperandOfReadonlyTypeOperator,
|
|
parenthesizeNonArrayTypeOfPostfixType,
|
|
parenthesizeElementTypesOfTupleType,
|
|
parenthesizeElementTypeOfTupleType,
|
|
parenthesizeTypeOfOptionalType,
|
|
parenthesizeTypeArguments,
|
|
parenthesizeLeadingTypeArgument
|
|
};
|
|
function getParenthesizeLeftSideOfBinaryForOperator(operatorKind) {
|
|
binaryLeftOperandParenthesizerCache || (binaryLeftOperandParenthesizerCache = /* @__PURE__ */ new Map());
|
|
let parenthesizerRule = binaryLeftOperandParenthesizerCache.get(operatorKind);
|
|
if (!parenthesizerRule) {
|
|
parenthesizerRule = (node) => parenthesizeLeftSideOfBinary(operatorKind, node);
|
|
binaryLeftOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
|
|
}
|
|
return parenthesizerRule;
|
|
}
|
|
function getParenthesizeRightSideOfBinaryForOperator(operatorKind) {
|
|
binaryRightOperandParenthesizerCache || (binaryRightOperandParenthesizerCache = /* @__PURE__ */ new Map());
|
|
let parenthesizerRule = binaryRightOperandParenthesizerCache.get(operatorKind);
|
|
if (!parenthesizerRule) {
|
|
parenthesizerRule = (node) => parenthesizeRightSideOfBinary(operatorKind, void 0, node);
|
|
binaryRightOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
|
|
}
|
|
return parenthesizerRule;
|
|
}
|
|
function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
|
|
const binaryOperatorPrecedence = getOperatorPrecedence(223 /* BinaryExpression */, binaryOperator);
|
|
const binaryOperatorAssociativity = getOperatorAssociativity(223 /* BinaryExpression */, binaryOperator);
|
|
const emittedOperand = skipPartiallyEmittedExpressions(operand);
|
|
if (!isLeftSideOfBinary && operand.kind === 216 /* ArrowFunction */ && binaryOperatorPrecedence > 3 /* Assignment */) {
|
|
return true;
|
|
}
|
|
const operandPrecedence = getExpressionPrecedence(emittedOperand);
|
|
switch (compareValues(operandPrecedence, binaryOperatorPrecedence)) {
|
|
case -1 /* LessThan */:
|
|
if (!isLeftSideOfBinary && binaryOperatorAssociativity === 1 /* Right */ && operand.kind === 226 /* YieldExpression */) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case 1 /* GreaterThan */:
|
|
return false;
|
|
case 0 /* EqualTo */:
|
|
if (isLeftSideOfBinary) {
|
|
return binaryOperatorAssociativity === 1 /* Right */;
|
|
} else {
|
|
if (isBinaryExpression(emittedOperand) && emittedOperand.operatorToken.kind === binaryOperator) {
|
|
if (operatorHasAssociativeProperty(binaryOperator)) {
|
|
return false;
|
|
}
|
|
if (binaryOperator === 39 /* PlusToken */) {
|
|
const leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0 /* Unknown */;
|
|
if (isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
const operandAssociativity = getExpressionAssociativity(emittedOperand);
|
|
return operandAssociativity === 0 /* Left */;
|
|
}
|
|
}
|
|
}
|
|
function operatorHasAssociativeProperty(binaryOperator) {
|
|
return binaryOperator === 41 /* AsteriskToken */ || binaryOperator === 51 /* BarToken */ || binaryOperator === 50 /* AmpersandToken */ || binaryOperator === 52 /* CaretToken */ || binaryOperator === 27 /* CommaToken */;
|
|
}
|
|
function getLiteralKindOfBinaryPlusOperand(node) {
|
|
node = skipPartiallyEmittedExpressions(node);
|
|
if (isLiteralKind(node.kind)) {
|
|
return node.kind;
|
|
}
|
|
if (node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 39 /* PlusToken */) {
|
|
if (node.cachedLiteralKind !== void 0) {
|
|
return node.cachedLiteralKind;
|
|
}
|
|
const leftKind = getLiteralKindOfBinaryPlusOperand(node.left);
|
|
const literalKind = isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) ? leftKind : 0 /* Unknown */;
|
|
node.cachedLiteralKind = literalKind;
|
|
return literalKind;
|
|
}
|
|
return 0 /* Unknown */;
|
|
}
|
|
function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
|
|
const skipped = skipPartiallyEmittedExpressions(operand);
|
|
if (skipped.kind === 214 /* ParenthesizedExpression */) {
|
|
return operand;
|
|
}
|
|
return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) ? factory2.createParenthesizedExpression(operand) : operand;
|
|
}
|
|
function parenthesizeLeftSideOfBinary(binaryOperator, leftSide) {
|
|
return parenthesizeBinaryOperand(binaryOperator, leftSide, true);
|
|
}
|
|
function parenthesizeRightSideOfBinary(binaryOperator, leftSide, rightSide) {
|
|
return parenthesizeBinaryOperand(binaryOperator, rightSide, false, leftSide);
|
|
}
|
|
function parenthesizeExpressionOfComputedPropertyName(expression) {
|
|
return isCommaSequence(expression) ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
function parenthesizeConditionOfConditionalExpression(condition) {
|
|
const conditionalPrecedence = getOperatorPrecedence(224 /* ConditionalExpression */, 57 /* QuestionToken */);
|
|
const emittedCondition = skipPartiallyEmittedExpressions(condition);
|
|
const conditionPrecedence = getExpressionPrecedence(emittedCondition);
|
|
if (compareValues(conditionPrecedence, conditionalPrecedence) !== 1 /* GreaterThan */) {
|
|
return factory2.createParenthesizedExpression(condition);
|
|
}
|
|
return condition;
|
|
}
|
|
function parenthesizeBranchOfConditionalExpression(branch) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(branch);
|
|
return isCommaSequence(emittedExpression) ? factory2.createParenthesizedExpression(branch) : branch;
|
|
}
|
|
function parenthesizeExpressionOfExportDefault(expression) {
|
|
const check = skipPartiallyEmittedExpressions(expression);
|
|
let needsParens = isCommaSequence(check);
|
|
if (!needsParens) {
|
|
switch (getLeftmostExpression(check, false).kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
needsParens = true;
|
|
}
|
|
}
|
|
return needsParens ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
function parenthesizeExpressionOfNew(expression) {
|
|
const leftmostExpr = getLeftmostExpression(expression, true);
|
|
switch (leftmostExpr.kind) {
|
|
case 210 /* CallExpression */:
|
|
return factory2.createParenthesizedExpression(expression);
|
|
case 211 /* NewExpression */:
|
|
return !leftmostExpr.arguments ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
return parenthesizeLeftSideOfAccess(expression);
|
|
}
|
|
function parenthesizeLeftSideOfAccess(expression, optionalChain) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (isLeftHandSideExpression(emittedExpression) && (emittedExpression.kind !== 211 /* NewExpression */ || emittedExpression.arguments) && (optionalChain || !isOptionalChain(emittedExpression))) {
|
|
return expression;
|
|
}
|
|
return setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
function parenthesizeOperandOfPostfixUnary(operand) {
|
|
return isLeftHandSideExpression(operand) ? operand : setTextRange(factory2.createParenthesizedExpression(operand), operand);
|
|
}
|
|
function parenthesizeOperandOfPrefixUnary(operand) {
|
|
return isUnaryExpression(operand) ? operand : setTextRange(factory2.createParenthesizedExpression(operand), operand);
|
|
}
|
|
function parenthesizeExpressionsOfCommaDelimitedList(elements) {
|
|
const result = sameMap(elements, parenthesizeExpressionForDisallowedComma);
|
|
return setTextRange(factory2.createNodeArray(result, elements.hasTrailingComma), elements);
|
|
}
|
|
function parenthesizeExpressionForDisallowedComma(expression) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
const expressionPrecedence = getExpressionPrecedence(emittedExpression);
|
|
const commaPrecedence = getOperatorPrecedence(223 /* BinaryExpression */, 27 /* CommaToken */);
|
|
return expressionPrecedence > commaPrecedence ? expression : setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
function parenthesizeExpressionOfExpressionStatement(expression) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (isCallExpression(emittedExpression)) {
|
|
const callee = emittedExpression.expression;
|
|
const kind = skipPartiallyEmittedExpressions(callee).kind;
|
|
if (kind === 215 /* FunctionExpression */ || kind === 216 /* ArrowFunction */) {
|
|
const updated = factory2.updateCallExpression(
|
|
emittedExpression,
|
|
setTextRange(factory2.createParenthesizedExpression(callee), callee),
|
|
emittedExpression.typeArguments,
|
|
emittedExpression.arguments
|
|
);
|
|
return factory2.restoreOuterExpressions(expression, updated, 8 /* PartiallyEmittedExpressions */);
|
|
}
|
|
}
|
|
const leftmostExpressionKind = getLeftmostExpression(emittedExpression, false).kind;
|
|
if (leftmostExpressionKind === 207 /* ObjectLiteralExpression */ || leftmostExpressionKind === 215 /* FunctionExpression */) {
|
|
return setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function parenthesizeConciseBodyOfArrowFunction(body) {
|
|
if (!isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, false).kind === 207 /* ObjectLiteralExpression */)) {
|
|
return setTextRange(factory2.createParenthesizedExpression(body), body);
|
|
}
|
|
return body;
|
|
}
|
|
function parenthesizeCheckTypeOfConditionalType(checkType) {
|
|
switch (checkType.kind) {
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 191 /* ConditionalType */:
|
|
return factory2.createParenthesizedType(checkType);
|
|
}
|
|
return checkType;
|
|
}
|
|
function parenthesizeExtendsTypeOfConditionalType(extendsType) {
|
|
switch (extendsType.kind) {
|
|
case 191 /* ConditionalType */:
|
|
return factory2.createParenthesizedType(extendsType);
|
|
}
|
|
return extendsType;
|
|
}
|
|
function parenthesizeConstituentTypeOfUnionType(type) {
|
|
switch (type.kind) {
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeCheckTypeOfConditionalType(type);
|
|
}
|
|
function parenthesizeConstituentTypesOfUnionType(members) {
|
|
return factory2.createNodeArray(sameMap(members, parenthesizeConstituentTypeOfUnionType));
|
|
}
|
|
function parenthesizeConstituentTypeOfIntersectionType(type) {
|
|
switch (type.kind) {
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeConstituentTypeOfUnionType(type);
|
|
}
|
|
function parenthesizeConstituentTypesOfIntersectionType(members) {
|
|
return factory2.createNodeArray(sameMap(members, parenthesizeConstituentTypeOfIntersectionType));
|
|
}
|
|
function parenthesizeOperandOfTypeOperator(type) {
|
|
switch (type.kind) {
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeConstituentTypeOfIntersectionType(type);
|
|
}
|
|
function parenthesizeOperandOfReadonlyTypeOperator(type) {
|
|
switch (type.kind) {
|
|
case 195 /* TypeOperator */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeOperandOfTypeOperator(type);
|
|
}
|
|
function parenthesizeNonArrayTypeOfPostfixType(type) {
|
|
switch (type.kind) {
|
|
case 192 /* InferType */:
|
|
case 195 /* TypeOperator */:
|
|
case 183 /* TypeQuery */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeOperandOfTypeOperator(type);
|
|
}
|
|
function parenthesizeElementTypesOfTupleType(types) {
|
|
return factory2.createNodeArray(sameMap(types, parenthesizeElementTypeOfTupleType));
|
|
}
|
|
function parenthesizeElementTypeOfTupleType(type) {
|
|
if (hasJSDocPostfixQuestion(type))
|
|
return factory2.createParenthesizedType(type);
|
|
return type;
|
|
}
|
|
function hasJSDocPostfixQuestion(type) {
|
|
if (isJSDocNullableType(type))
|
|
return type.postfix;
|
|
if (isNamedTupleMember(type))
|
|
return hasJSDocPostfixQuestion(type.type);
|
|
if (isFunctionTypeNode(type) || isConstructorTypeNode(type) || isTypeOperatorNode(type))
|
|
return hasJSDocPostfixQuestion(type.type);
|
|
if (isConditionalTypeNode(type))
|
|
return hasJSDocPostfixQuestion(type.falseType);
|
|
if (isUnionTypeNode(type))
|
|
return hasJSDocPostfixQuestion(last(type.types));
|
|
if (isIntersectionTypeNode(type))
|
|
return hasJSDocPostfixQuestion(last(type.types));
|
|
if (isInferTypeNode(type))
|
|
return !!type.typeParameter.constraint && hasJSDocPostfixQuestion(type.typeParameter.constraint);
|
|
return false;
|
|
}
|
|
function parenthesizeTypeOfOptionalType(type) {
|
|
if (hasJSDocPostfixQuestion(type))
|
|
return factory2.createParenthesizedType(type);
|
|
return parenthesizeNonArrayTypeOfPostfixType(type);
|
|
}
|
|
function parenthesizeLeadingTypeArgument(node) {
|
|
return isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory2.createParenthesizedType(node) : node;
|
|
}
|
|
function parenthesizeOrdinalTypeArgument(node, i) {
|
|
return i === 0 ? parenthesizeLeadingTypeArgument(node) : node;
|
|
}
|
|
function parenthesizeTypeArguments(typeArguments) {
|
|
if (some(typeArguments)) {
|
|
return factory2.createNodeArray(sameMap(typeArguments, parenthesizeOrdinalTypeArgument));
|
|
}
|
|
}
|
|
}
|
|
var nullParenthesizerRules = {
|
|
getParenthesizeLeftSideOfBinaryForOperator: (_) => identity,
|
|
getParenthesizeRightSideOfBinaryForOperator: (_) => identity,
|
|
parenthesizeLeftSideOfBinary: (_binaryOperator, leftSide) => leftSide,
|
|
parenthesizeRightSideOfBinary: (_binaryOperator, _leftSide, rightSide) => rightSide,
|
|
parenthesizeExpressionOfComputedPropertyName: identity,
|
|
parenthesizeConditionOfConditionalExpression: identity,
|
|
parenthesizeBranchOfConditionalExpression: identity,
|
|
parenthesizeExpressionOfExportDefault: identity,
|
|
parenthesizeExpressionOfNew: (expression) => cast(expression, isLeftHandSideExpression),
|
|
parenthesizeLeftSideOfAccess: (expression) => cast(expression, isLeftHandSideExpression),
|
|
parenthesizeOperandOfPostfixUnary: (operand) => cast(operand, isLeftHandSideExpression),
|
|
parenthesizeOperandOfPrefixUnary: (operand) => cast(operand, isUnaryExpression),
|
|
parenthesizeExpressionsOfCommaDelimitedList: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeExpressionForDisallowedComma: identity,
|
|
parenthesizeExpressionOfExpressionStatement: identity,
|
|
parenthesizeConciseBodyOfArrowFunction: identity,
|
|
parenthesizeCheckTypeOfConditionalType: identity,
|
|
parenthesizeExtendsTypeOfConditionalType: identity,
|
|
parenthesizeConstituentTypesOfUnionType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeConstituentTypeOfUnionType: identity,
|
|
parenthesizeConstituentTypesOfIntersectionType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeConstituentTypeOfIntersectionType: identity,
|
|
parenthesizeOperandOfTypeOperator: identity,
|
|
parenthesizeOperandOfReadonlyTypeOperator: identity,
|
|
parenthesizeNonArrayTypeOfPostfixType: identity,
|
|
parenthesizeElementTypesOfTupleType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeElementTypeOfTupleType: identity,
|
|
parenthesizeTypeOfOptionalType: identity,
|
|
parenthesizeTypeArguments: (nodes) => nodes && cast(nodes, isNodeArray),
|
|
parenthesizeLeadingTypeArgument: identity
|
|
};
|
|
|
|
// src/compiler/factory/nodeConverters.ts
|
|
function createNodeConverters(factory2) {
|
|
return {
|
|
convertToFunctionBlock,
|
|
convertToFunctionExpression,
|
|
convertToArrayAssignmentElement,
|
|
convertToObjectAssignmentElement,
|
|
convertToAssignmentPattern,
|
|
convertToObjectAssignmentPattern,
|
|
convertToArrayAssignmentPattern,
|
|
convertToAssignmentElementTarget
|
|
};
|
|
function convertToFunctionBlock(node, multiLine) {
|
|
if (isBlock(node))
|
|
return node;
|
|
const returnStatement = factory2.createReturnStatement(node);
|
|
setTextRange(returnStatement, node);
|
|
const body = factory2.createBlock([returnStatement], multiLine);
|
|
setTextRange(body, node);
|
|
return body;
|
|
}
|
|
function convertToFunctionExpression(node) {
|
|
if (!node.body)
|
|
return Debug.fail(`Cannot convert a FunctionDeclaration without a body`);
|
|
const updated = factory2.createFunctionExpression(
|
|
node.modifiers,
|
|
node.asteriskToken,
|
|
node.name,
|
|
node.typeParameters,
|
|
node.parameters,
|
|
node.type,
|
|
node.body
|
|
);
|
|
setOriginalNode(updated, node);
|
|
setTextRange(updated, node);
|
|
if (getStartsOnNewLine(node)) {
|
|
setStartsOnNewLine(updated, true);
|
|
}
|
|
return updated;
|
|
}
|
|
function convertToArrayAssignmentElement(element) {
|
|
if (isBindingElement(element)) {
|
|
if (element.dotDotDotToken) {
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createSpreadElement(element.name), element), element);
|
|
}
|
|
const expression = convertToAssignmentElementTarget(element.name);
|
|
return element.initializer ? setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(expression, element.initializer),
|
|
element
|
|
),
|
|
element
|
|
) : expression;
|
|
}
|
|
return cast(element, isExpression);
|
|
}
|
|
function convertToObjectAssignmentElement(element) {
|
|
if (isBindingElement(element)) {
|
|
if (element.dotDotDotToken) {
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createSpreadAssignment(element.name), element), element);
|
|
}
|
|
if (element.propertyName) {
|
|
const expression = convertToAssignmentElementTarget(element.name);
|
|
return setOriginalNode(setTextRange(factory2.createPropertyAssignment(element.propertyName, element.initializer ? factory2.createAssignment(expression, element.initializer) : expression), element), element);
|
|
}
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createShorthandPropertyAssignment(element.name, element.initializer), element), element);
|
|
}
|
|
return cast(element, isObjectLiteralElementLike);
|
|
}
|
|
function convertToAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return convertToArrayAssignmentPattern(node);
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return convertToObjectAssignmentPattern(node);
|
|
}
|
|
}
|
|
function convertToObjectAssignmentPattern(node) {
|
|
if (isObjectBindingPattern(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createObjectLiteralExpression(map(node.elements, convertToObjectAssignmentElement)),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return cast(node, isObjectLiteralExpression);
|
|
}
|
|
function convertToArrayAssignmentPattern(node) {
|
|
if (isArrayBindingPattern(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createArrayLiteralExpression(map(node.elements, convertToArrayAssignmentElement)),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return cast(node, isArrayLiteralExpression);
|
|
}
|
|
function convertToAssignmentElementTarget(node) {
|
|
if (isBindingPattern(node)) {
|
|
return convertToAssignmentPattern(node);
|
|
}
|
|
return cast(node, isExpression);
|
|
}
|
|
}
|
|
var nullNodeConverters = {
|
|
convertToFunctionBlock: notImplemented,
|
|
convertToFunctionExpression: notImplemented,
|
|
convertToArrayAssignmentElement: notImplemented,
|
|
convertToObjectAssignmentElement: notImplemented,
|
|
convertToAssignmentPattern: notImplemented,
|
|
convertToObjectAssignmentPattern: notImplemented,
|
|
convertToArrayAssignmentPattern: notImplemented,
|
|
convertToAssignmentElementTarget: notImplemented
|
|
};
|
|
|
|
// src/compiler/factory/nodeFactory.ts
|
|
var nextAutoGenerateId = 0;
|
|
var nodeFactoryPatchers = [];
|
|
function createNodeFactory(flags, baseFactory2) {
|
|
const update = flags & 8 /* NoOriginalNode */ ? updateWithoutOriginal : updateWithOriginal;
|
|
const parenthesizerRules = memoize(() => flags & 1 /* NoParenthesizerRules */ ? nullParenthesizerRules : createParenthesizerRules(factory2));
|
|
const converters = memoize(() => flags & 2 /* NoNodeConverters */ ? nullNodeConverters : createNodeConverters(factory2));
|
|
const getBinaryCreateFunction = memoizeOne((operator) => (left, right) => createBinaryExpression(left, operator, right));
|
|
const getPrefixUnaryCreateFunction = memoizeOne((operator) => (operand) => createPrefixUnaryExpression(operator, operand));
|
|
const getPostfixUnaryCreateFunction = memoizeOne((operator) => (operand) => createPostfixUnaryExpression(operand, operator));
|
|
const getJSDocPrimaryTypeCreateFunction = memoizeOne((kind) => () => createJSDocPrimaryTypeWorker(kind));
|
|
const getJSDocUnaryTypeCreateFunction = memoizeOne((kind) => (type) => createJSDocUnaryTypeWorker(kind, type));
|
|
const getJSDocUnaryTypeUpdateFunction = memoizeOne((kind) => (node, type) => updateJSDocUnaryTypeWorker(kind, node, type));
|
|
const getJSDocPrePostfixUnaryTypeCreateFunction = memoizeOne((kind) => (type, postfix) => createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix));
|
|
const getJSDocPrePostfixUnaryTypeUpdateFunction = memoizeOne((kind) => (node, type) => updateJSDocPrePostfixUnaryTypeWorker(kind, node, type));
|
|
const getJSDocSimpleTagCreateFunction = memoizeOne((kind) => (tagName, comment) => createJSDocSimpleTagWorker(kind, tagName, comment));
|
|
const getJSDocSimpleTagUpdateFunction = memoizeOne((kind) => (node, tagName, comment) => updateJSDocSimpleTagWorker(kind, node, tagName, comment));
|
|
const getJSDocTypeLikeTagCreateFunction = memoizeOne((kind) => (tagName, typeExpression, comment) => createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment));
|
|
const getJSDocTypeLikeTagUpdateFunction = memoizeOne((kind) => (node, tagName, typeExpression, comment) => updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment));
|
|
const factory2 = {
|
|
get parenthesizer() {
|
|
return parenthesizerRules();
|
|
},
|
|
get converters() {
|
|
return converters();
|
|
},
|
|
baseFactory: baseFactory2,
|
|
flags,
|
|
createNodeArray,
|
|
createNumericLiteral,
|
|
createBigIntLiteral,
|
|
createStringLiteral,
|
|
createStringLiteralFromNode,
|
|
createRegularExpressionLiteral,
|
|
createLiteralLikeNode,
|
|
createIdentifier,
|
|
updateIdentifier,
|
|
createTempVariable,
|
|
createLoopVariable,
|
|
createUniqueName,
|
|
getGeneratedNameForNode,
|
|
createPrivateIdentifier,
|
|
createUniquePrivateName,
|
|
getGeneratedPrivateNameForNode,
|
|
createToken,
|
|
createSuper,
|
|
createThis,
|
|
createNull,
|
|
createTrue,
|
|
createFalse,
|
|
createModifier,
|
|
createModifiersFromModifierFlags,
|
|
createQualifiedName,
|
|
updateQualifiedName,
|
|
createComputedPropertyName,
|
|
updateComputedPropertyName,
|
|
createTypeParameterDeclaration,
|
|
updateTypeParameterDeclaration,
|
|
createParameterDeclaration,
|
|
updateParameterDeclaration,
|
|
createDecorator,
|
|
updateDecorator,
|
|
createPropertySignature,
|
|
updatePropertySignature,
|
|
createPropertyDeclaration,
|
|
updatePropertyDeclaration,
|
|
createMethodSignature,
|
|
updateMethodSignature,
|
|
createMethodDeclaration,
|
|
updateMethodDeclaration,
|
|
createConstructorDeclaration,
|
|
updateConstructorDeclaration,
|
|
createGetAccessorDeclaration,
|
|
updateGetAccessorDeclaration,
|
|
createSetAccessorDeclaration,
|
|
updateSetAccessorDeclaration,
|
|
createCallSignature,
|
|
updateCallSignature,
|
|
createConstructSignature,
|
|
updateConstructSignature,
|
|
createIndexSignature,
|
|
updateIndexSignature,
|
|
createClassStaticBlockDeclaration,
|
|
updateClassStaticBlockDeclaration,
|
|
createTemplateLiteralTypeSpan,
|
|
updateTemplateLiteralTypeSpan,
|
|
createKeywordTypeNode,
|
|
createTypePredicateNode,
|
|
updateTypePredicateNode,
|
|
createTypeReferenceNode,
|
|
updateTypeReferenceNode,
|
|
createFunctionTypeNode,
|
|
updateFunctionTypeNode,
|
|
createConstructorTypeNode,
|
|
updateConstructorTypeNode,
|
|
createTypeQueryNode,
|
|
updateTypeQueryNode,
|
|
createTypeLiteralNode,
|
|
updateTypeLiteralNode,
|
|
createArrayTypeNode,
|
|
updateArrayTypeNode,
|
|
createTupleTypeNode,
|
|
updateTupleTypeNode,
|
|
createNamedTupleMember,
|
|
updateNamedTupleMember,
|
|
createOptionalTypeNode,
|
|
updateOptionalTypeNode,
|
|
createRestTypeNode,
|
|
updateRestTypeNode,
|
|
createUnionTypeNode,
|
|
updateUnionTypeNode,
|
|
createIntersectionTypeNode,
|
|
updateIntersectionTypeNode,
|
|
createConditionalTypeNode,
|
|
updateConditionalTypeNode,
|
|
createInferTypeNode,
|
|
updateInferTypeNode,
|
|
createImportTypeNode,
|
|
updateImportTypeNode,
|
|
createParenthesizedType,
|
|
updateParenthesizedType,
|
|
createThisTypeNode,
|
|
createTypeOperatorNode,
|
|
updateTypeOperatorNode,
|
|
createIndexedAccessTypeNode,
|
|
updateIndexedAccessTypeNode,
|
|
createMappedTypeNode,
|
|
updateMappedTypeNode,
|
|
createLiteralTypeNode,
|
|
updateLiteralTypeNode,
|
|
createTemplateLiteralType,
|
|
updateTemplateLiteralType,
|
|
createObjectBindingPattern,
|
|
updateObjectBindingPattern,
|
|
createArrayBindingPattern,
|
|
updateArrayBindingPattern,
|
|
createBindingElement,
|
|
updateBindingElement,
|
|
createArrayLiteralExpression,
|
|
updateArrayLiteralExpression,
|
|
createObjectLiteralExpression,
|
|
updateObjectLiteralExpression,
|
|
createPropertyAccessExpression: flags & 4 /* NoIndentationOnFreshPropertyAccess */ ? (expression, name) => setEmitFlags(createPropertyAccessExpression(expression, name), 262144 /* NoIndentation */) : createPropertyAccessExpression,
|
|
updatePropertyAccessExpression,
|
|
createPropertyAccessChain: flags & 4 /* NoIndentationOnFreshPropertyAccess */ ? (expression, questionDotToken, name) => setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), 262144 /* NoIndentation */) : createPropertyAccessChain,
|
|
updatePropertyAccessChain,
|
|
createElementAccessExpression,
|
|
updateElementAccessExpression,
|
|
createElementAccessChain,
|
|
updateElementAccessChain,
|
|
createCallExpression,
|
|
updateCallExpression,
|
|
createCallChain,
|
|
updateCallChain,
|
|
createNewExpression,
|
|
updateNewExpression,
|
|
createTaggedTemplateExpression,
|
|
updateTaggedTemplateExpression,
|
|
createTypeAssertion,
|
|
updateTypeAssertion,
|
|
createParenthesizedExpression,
|
|
updateParenthesizedExpression,
|
|
createFunctionExpression,
|
|
updateFunctionExpression,
|
|
createArrowFunction,
|
|
updateArrowFunction,
|
|
createDeleteExpression,
|
|
updateDeleteExpression,
|
|
createTypeOfExpression,
|
|
updateTypeOfExpression,
|
|
createVoidExpression,
|
|
updateVoidExpression,
|
|
createAwaitExpression,
|
|
updateAwaitExpression,
|
|
createPrefixUnaryExpression,
|
|
updatePrefixUnaryExpression,
|
|
createPostfixUnaryExpression,
|
|
updatePostfixUnaryExpression,
|
|
createBinaryExpression,
|
|
updateBinaryExpression,
|
|
createConditionalExpression,
|
|
updateConditionalExpression,
|
|
createTemplateExpression,
|
|
updateTemplateExpression,
|
|
createTemplateHead,
|
|
createTemplateMiddle,
|
|
createTemplateTail,
|
|
createNoSubstitutionTemplateLiteral,
|
|
createTemplateLiteralLikeNode,
|
|
createYieldExpression,
|
|
updateYieldExpression,
|
|
createSpreadElement,
|
|
updateSpreadElement,
|
|
createClassExpression,
|
|
updateClassExpression,
|
|
createOmittedExpression,
|
|
createExpressionWithTypeArguments,
|
|
updateExpressionWithTypeArguments,
|
|
createAsExpression,
|
|
updateAsExpression,
|
|
createNonNullExpression,
|
|
updateNonNullExpression,
|
|
createSatisfiesExpression,
|
|
updateSatisfiesExpression,
|
|
createNonNullChain,
|
|
updateNonNullChain,
|
|
createMetaProperty,
|
|
updateMetaProperty,
|
|
createTemplateSpan,
|
|
updateTemplateSpan,
|
|
createSemicolonClassElement,
|
|
createBlock,
|
|
updateBlock,
|
|
createVariableStatement,
|
|
updateVariableStatement,
|
|
createEmptyStatement,
|
|
createExpressionStatement,
|
|
updateExpressionStatement,
|
|
createIfStatement,
|
|
updateIfStatement,
|
|
createDoStatement,
|
|
updateDoStatement,
|
|
createWhileStatement,
|
|
updateWhileStatement,
|
|
createForStatement,
|
|
updateForStatement,
|
|
createForInStatement,
|
|
updateForInStatement,
|
|
createForOfStatement,
|
|
updateForOfStatement,
|
|
createContinueStatement,
|
|
updateContinueStatement,
|
|
createBreakStatement,
|
|
updateBreakStatement,
|
|
createReturnStatement,
|
|
updateReturnStatement,
|
|
createWithStatement,
|
|
updateWithStatement,
|
|
createSwitchStatement,
|
|
updateSwitchStatement,
|
|
createLabeledStatement,
|
|
updateLabeledStatement,
|
|
createThrowStatement,
|
|
updateThrowStatement,
|
|
createTryStatement,
|
|
updateTryStatement,
|
|
createDebuggerStatement,
|
|
createVariableDeclaration,
|
|
updateVariableDeclaration,
|
|
createVariableDeclarationList,
|
|
updateVariableDeclarationList,
|
|
createFunctionDeclaration,
|
|
updateFunctionDeclaration,
|
|
createClassDeclaration,
|
|
updateClassDeclaration,
|
|
createInterfaceDeclaration,
|
|
updateInterfaceDeclaration,
|
|
createTypeAliasDeclaration,
|
|
updateTypeAliasDeclaration,
|
|
createEnumDeclaration,
|
|
updateEnumDeclaration,
|
|
createModuleDeclaration,
|
|
updateModuleDeclaration,
|
|
createModuleBlock,
|
|
updateModuleBlock,
|
|
createCaseBlock,
|
|
updateCaseBlock,
|
|
createNamespaceExportDeclaration,
|
|
updateNamespaceExportDeclaration,
|
|
createImportEqualsDeclaration,
|
|
updateImportEqualsDeclaration,
|
|
createImportDeclaration,
|
|
updateImportDeclaration,
|
|
createImportClause,
|
|
updateImportClause,
|
|
createAssertClause,
|
|
updateAssertClause,
|
|
createAssertEntry,
|
|
updateAssertEntry,
|
|
createImportTypeAssertionContainer,
|
|
updateImportTypeAssertionContainer,
|
|
createNamespaceImport,
|
|
updateNamespaceImport,
|
|
createNamespaceExport,
|
|
updateNamespaceExport,
|
|
createNamedImports,
|
|
updateNamedImports,
|
|
createImportSpecifier,
|
|
updateImportSpecifier,
|
|
createExportAssignment,
|
|
updateExportAssignment,
|
|
createExportDeclaration,
|
|
updateExportDeclaration,
|
|
createNamedExports,
|
|
updateNamedExports,
|
|
createExportSpecifier,
|
|
updateExportSpecifier,
|
|
createMissingDeclaration,
|
|
createExternalModuleReference,
|
|
updateExternalModuleReference,
|
|
get createJSDocAllType() {
|
|
return getJSDocPrimaryTypeCreateFunction(315 /* JSDocAllType */);
|
|
},
|
|
get createJSDocUnknownType() {
|
|
return getJSDocPrimaryTypeCreateFunction(316 /* JSDocUnknownType */);
|
|
},
|
|
get createJSDocNonNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeCreateFunction(318 /* JSDocNonNullableType */);
|
|
},
|
|
get updateJSDocNonNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeUpdateFunction(318 /* JSDocNonNullableType */);
|
|
},
|
|
get createJSDocNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeCreateFunction(317 /* JSDocNullableType */);
|
|
},
|
|
get updateJSDocNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeUpdateFunction(317 /* JSDocNullableType */);
|
|
},
|
|
get createJSDocOptionalType() {
|
|
return getJSDocUnaryTypeCreateFunction(319 /* JSDocOptionalType */);
|
|
},
|
|
get updateJSDocOptionalType() {
|
|
return getJSDocUnaryTypeUpdateFunction(319 /* JSDocOptionalType */);
|
|
},
|
|
get createJSDocVariadicType() {
|
|
return getJSDocUnaryTypeCreateFunction(321 /* JSDocVariadicType */);
|
|
},
|
|
get updateJSDocVariadicType() {
|
|
return getJSDocUnaryTypeUpdateFunction(321 /* JSDocVariadicType */);
|
|
},
|
|
get createJSDocNamepathType() {
|
|
return getJSDocUnaryTypeCreateFunction(322 /* JSDocNamepathType */);
|
|
},
|
|
get updateJSDocNamepathType() {
|
|
return getJSDocUnaryTypeUpdateFunction(322 /* JSDocNamepathType */);
|
|
},
|
|
createJSDocFunctionType,
|
|
updateJSDocFunctionType,
|
|
createJSDocTypeLiteral,
|
|
updateJSDocTypeLiteral,
|
|
createJSDocTypeExpression,
|
|
updateJSDocTypeExpression,
|
|
createJSDocSignature,
|
|
updateJSDocSignature,
|
|
createJSDocTemplateTag,
|
|
updateJSDocTemplateTag,
|
|
createJSDocTypedefTag,
|
|
updateJSDocTypedefTag,
|
|
createJSDocParameterTag,
|
|
updateJSDocParameterTag,
|
|
createJSDocPropertyTag,
|
|
updateJSDocPropertyTag,
|
|
createJSDocCallbackTag,
|
|
updateJSDocCallbackTag,
|
|
createJSDocAugmentsTag,
|
|
updateJSDocAugmentsTag,
|
|
createJSDocImplementsTag,
|
|
updateJSDocImplementsTag,
|
|
createJSDocSeeTag,
|
|
updateJSDocSeeTag,
|
|
createJSDocNameReference,
|
|
updateJSDocNameReference,
|
|
createJSDocMemberName,
|
|
updateJSDocMemberName,
|
|
createJSDocLink,
|
|
updateJSDocLink,
|
|
createJSDocLinkCode,
|
|
updateJSDocLinkCode,
|
|
createJSDocLinkPlain,
|
|
updateJSDocLinkPlain,
|
|
get createJSDocTypeTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(346 /* JSDocTypeTag */);
|
|
},
|
|
get updateJSDocTypeTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(346 /* JSDocTypeTag */);
|
|
},
|
|
get createJSDocReturnTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(344 /* JSDocReturnTag */);
|
|
},
|
|
get updateJSDocReturnTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(344 /* JSDocReturnTag */);
|
|
},
|
|
get createJSDocThisTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(345 /* JSDocThisTag */);
|
|
},
|
|
get updateJSDocThisTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(345 /* JSDocThisTag */);
|
|
},
|
|
get createJSDocEnumTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(342 /* JSDocEnumTag */);
|
|
},
|
|
get updateJSDocEnumTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(342 /* JSDocEnumTag */);
|
|
},
|
|
get createJSDocAuthorTag() {
|
|
return getJSDocSimpleTagCreateFunction(333 /* JSDocAuthorTag */);
|
|
},
|
|
get updateJSDocAuthorTag() {
|
|
return getJSDocSimpleTagUpdateFunction(333 /* JSDocAuthorTag */);
|
|
},
|
|
get createJSDocClassTag() {
|
|
return getJSDocSimpleTagCreateFunction(335 /* JSDocClassTag */);
|
|
},
|
|
get updateJSDocClassTag() {
|
|
return getJSDocSimpleTagUpdateFunction(335 /* JSDocClassTag */);
|
|
},
|
|
get createJSDocPublicTag() {
|
|
return getJSDocSimpleTagCreateFunction(336 /* JSDocPublicTag */);
|
|
},
|
|
get updateJSDocPublicTag() {
|
|
return getJSDocSimpleTagUpdateFunction(336 /* JSDocPublicTag */);
|
|
},
|
|
get createJSDocPrivateTag() {
|
|
return getJSDocSimpleTagCreateFunction(337 /* JSDocPrivateTag */);
|
|
},
|
|
get updateJSDocPrivateTag() {
|
|
return getJSDocSimpleTagUpdateFunction(337 /* JSDocPrivateTag */);
|
|
},
|
|
get createJSDocProtectedTag() {
|
|
return getJSDocSimpleTagCreateFunction(338 /* JSDocProtectedTag */);
|
|
},
|
|
get updateJSDocProtectedTag() {
|
|
return getJSDocSimpleTagUpdateFunction(338 /* JSDocProtectedTag */);
|
|
},
|
|
get createJSDocReadonlyTag() {
|
|
return getJSDocSimpleTagCreateFunction(339 /* JSDocReadonlyTag */);
|
|
},
|
|
get updateJSDocReadonlyTag() {
|
|
return getJSDocSimpleTagUpdateFunction(339 /* JSDocReadonlyTag */);
|
|
},
|
|
get createJSDocOverrideTag() {
|
|
return getJSDocSimpleTagCreateFunction(340 /* JSDocOverrideTag */);
|
|
},
|
|
get updateJSDocOverrideTag() {
|
|
return getJSDocSimpleTagUpdateFunction(340 /* JSDocOverrideTag */);
|
|
},
|
|
get createJSDocDeprecatedTag() {
|
|
return getJSDocSimpleTagCreateFunction(334 /* JSDocDeprecatedTag */);
|
|
},
|
|
get updateJSDocDeprecatedTag() {
|
|
return getJSDocSimpleTagUpdateFunction(334 /* JSDocDeprecatedTag */);
|
|
},
|
|
createJSDocUnknownTag,
|
|
updateJSDocUnknownTag,
|
|
createJSDocText,
|
|
updateJSDocText,
|
|
createJSDocComment,
|
|
updateJSDocComment,
|
|
createJsxElement,
|
|
updateJsxElement,
|
|
createJsxSelfClosingElement,
|
|
updateJsxSelfClosingElement,
|
|
createJsxOpeningElement,
|
|
updateJsxOpeningElement,
|
|
createJsxClosingElement,
|
|
updateJsxClosingElement,
|
|
createJsxFragment,
|
|
createJsxText,
|
|
updateJsxText,
|
|
createJsxOpeningFragment,
|
|
createJsxJsxClosingFragment,
|
|
updateJsxFragment,
|
|
createJsxAttribute,
|
|
updateJsxAttribute,
|
|
createJsxAttributes,
|
|
updateJsxAttributes,
|
|
createJsxSpreadAttribute,
|
|
updateJsxSpreadAttribute,
|
|
createJsxExpression,
|
|
updateJsxExpression,
|
|
createCaseClause,
|
|
updateCaseClause,
|
|
createDefaultClause,
|
|
updateDefaultClause,
|
|
createHeritageClause,
|
|
updateHeritageClause,
|
|
createCatchClause,
|
|
updateCatchClause,
|
|
createPropertyAssignment,
|
|
updatePropertyAssignment,
|
|
createShorthandPropertyAssignment,
|
|
updateShorthandPropertyAssignment,
|
|
createSpreadAssignment,
|
|
updateSpreadAssignment,
|
|
createEnumMember,
|
|
updateEnumMember,
|
|
createSourceFile: createSourceFile2,
|
|
updateSourceFile,
|
|
createBundle,
|
|
updateBundle,
|
|
createUnparsedSource,
|
|
createUnparsedPrologue,
|
|
createUnparsedPrepend,
|
|
createUnparsedTextLike,
|
|
createUnparsedSyntheticReference,
|
|
createInputFiles,
|
|
createSyntheticExpression,
|
|
createSyntaxList,
|
|
createNotEmittedStatement,
|
|
createPartiallyEmittedExpression,
|
|
updatePartiallyEmittedExpression,
|
|
createCommaListExpression,
|
|
updateCommaListExpression,
|
|
createEndOfDeclarationMarker,
|
|
createMergeDeclarationMarker,
|
|
createSyntheticReferenceExpression,
|
|
updateSyntheticReferenceExpression,
|
|
cloneNode,
|
|
get createComma() {
|
|
return getBinaryCreateFunction(27 /* CommaToken */);
|
|
},
|
|
get createAssignment() {
|
|
return getBinaryCreateFunction(63 /* EqualsToken */);
|
|
},
|
|
get createLogicalOr() {
|
|
return getBinaryCreateFunction(56 /* BarBarToken */);
|
|
},
|
|
get createLogicalAnd() {
|
|
return getBinaryCreateFunction(55 /* AmpersandAmpersandToken */);
|
|
},
|
|
get createBitwiseOr() {
|
|
return getBinaryCreateFunction(51 /* BarToken */);
|
|
},
|
|
get createBitwiseXor() {
|
|
return getBinaryCreateFunction(52 /* CaretToken */);
|
|
},
|
|
get createBitwiseAnd() {
|
|
return getBinaryCreateFunction(50 /* AmpersandToken */);
|
|
},
|
|
get createStrictEquality() {
|
|
return getBinaryCreateFunction(36 /* EqualsEqualsEqualsToken */);
|
|
},
|
|
get createStrictInequality() {
|
|
return getBinaryCreateFunction(37 /* ExclamationEqualsEqualsToken */);
|
|
},
|
|
get createEquality() {
|
|
return getBinaryCreateFunction(34 /* EqualsEqualsToken */);
|
|
},
|
|
get createInequality() {
|
|
return getBinaryCreateFunction(35 /* ExclamationEqualsToken */);
|
|
},
|
|
get createLessThan() {
|
|
return getBinaryCreateFunction(29 /* LessThanToken */);
|
|
},
|
|
get createLessThanEquals() {
|
|
return getBinaryCreateFunction(32 /* LessThanEqualsToken */);
|
|
},
|
|
get createGreaterThan() {
|
|
return getBinaryCreateFunction(31 /* GreaterThanToken */);
|
|
},
|
|
get createGreaterThanEquals() {
|
|
return getBinaryCreateFunction(33 /* GreaterThanEqualsToken */);
|
|
},
|
|
get createLeftShift() {
|
|
return getBinaryCreateFunction(47 /* LessThanLessThanToken */);
|
|
},
|
|
get createRightShift() {
|
|
return getBinaryCreateFunction(48 /* GreaterThanGreaterThanToken */);
|
|
},
|
|
get createUnsignedRightShift() {
|
|
return getBinaryCreateFunction(49 /* GreaterThanGreaterThanGreaterThanToken */);
|
|
},
|
|
get createAdd() {
|
|
return getBinaryCreateFunction(39 /* PlusToken */);
|
|
},
|
|
get createSubtract() {
|
|
return getBinaryCreateFunction(40 /* MinusToken */);
|
|
},
|
|
get createMultiply() {
|
|
return getBinaryCreateFunction(41 /* AsteriskToken */);
|
|
},
|
|
get createDivide() {
|
|
return getBinaryCreateFunction(43 /* SlashToken */);
|
|
},
|
|
get createModulo() {
|
|
return getBinaryCreateFunction(44 /* PercentToken */);
|
|
},
|
|
get createExponent() {
|
|
return getBinaryCreateFunction(42 /* AsteriskAsteriskToken */);
|
|
},
|
|
get createPrefixPlus() {
|
|
return getPrefixUnaryCreateFunction(39 /* PlusToken */);
|
|
},
|
|
get createPrefixMinus() {
|
|
return getPrefixUnaryCreateFunction(40 /* MinusToken */);
|
|
},
|
|
get createPrefixIncrement() {
|
|
return getPrefixUnaryCreateFunction(45 /* PlusPlusToken */);
|
|
},
|
|
get createPrefixDecrement() {
|
|
return getPrefixUnaryCreateFunction(46 /* MinusMinusToken */);
|
|
},
|
|
get createBitwiseNot() {
|
|
return getPrefixUnaryCreateFunction(54 /* TildeToken */);
|
|
},
|
|
get createLogicalNot() {
|
|
return getPrefixUnaryCreateFunction(53 /* ExclamationToken */);
|
|
},
|
|
get createPostfixIncrement() {
|
|
return getPostfixUnaryCreateFunction(45 /* PlusPlusToken */);
|
|
},
|
|
get createPostfixDecrement() {
|
|
return getPostfixUnaryCreateFunction(46 /* MinusMinusToken */);
|
|
},
|
|
createImmediatelyInvokedFunctionExpression,
|
|
createImmediatelyInvokedArrowFunction,
|
|
createVoidZero,
|
|
createExportDefault,
|
|
createExternalModuleExport,
|
|
createTypeCheck,
|
|
createMethodCall,
|
|
createGlobalMethodCall,
|
|
createFunctionBindCall,
|
|
createFunctionCallCall,
|
|
createFunctionApplyCall,
|
|
createArraySliceCall,
|
|
createArrayConcatCall,
|
|
createObjectDefinePropertyCall,
|
|
createReflectGetCall,
|
|
createReflectSetCall,
|
|
createPropertyDescriptor,
|
|
createCallBinding,
|
|
createAssignmentTargetWrapper,
|
|
inlineExpressions,
|
|
getInternalName,
|
|
getLocalName,
|
|
getExportName,
|
|
getDeclarationName,
|
|
getNamespaceMemberName,
|
|
getExternalModuleOrNamespaceExportName,
|
|
restoreOuterExpressions,
|
|
restoreEnclosingLabel,
|
|
createUseStrictPrologue,
|
|
copyPrologue,
|
|
copyStandardPrologue,
|
|
copyCustomPrologue,
|
|
ensureUseStrict,
|
|
liftToBlock,
|
|
mergeLexicalEnvironment,
|
|
updateModifiers
|
|
};
|
|
forEach(nodeFactoryPatchers, (fn) => fn(factory2));
|
|
return factory2;
|
|
function createNodeArray(elements, hasTrailingComma) {
|
|
if (elements === void 0 || elements === emptyArray) {
|
|
elements = [];
|
|
} else if (isNodeArray(elements)) {
|
|
if (hasTrailingComma === void 0 || elements.hasTrailingComma === hasTrailingComma) {
|
|
if (elements.transformFlags === void 0) {
|
|
aggregateChildrenFlags(elements);
|
|
}
|
|
Debug.attachNodeArrayDebugInfo(elements);
|
|
return elements;
|
|
}
|
|
const array2 = elements.slice();
|
|
array2.pos = elements.pos;
|
|
array2.end = elements.end;
|
|
array2.hasTrailingComma = hasTrailingComma;
|
|
array2.transformFlags = elements.transformFlags;
|
|
Debug.attachNodeArrayDebugInfo(array2);
|
|
return array2;
|
|
}
|
|
const length2 = elements.length;
|
|
const array = length2 >= 1 && length2 <= 4 ? elements.slice() : elements;
|
|
setTextRangePosEnd(array, -1, -1);
|
|
array.hasTrailingComma = !!hasTrailingComma;
|
|
aggregateChildrenFlags(array);
|
|
Debug.attachNodeArrayDebugInfo(array);
|
|
return array;
|
|
}
|
|
function createBaseNode(kind) {
|
|
return baseFactory2.createBaseNode(kind);
|
|
}
|
|
function createBaseDeclaration(kind) {
|
|
const node = createBaseNode(kind);
|
|
node.symbol = void 0;
|
|
node.localSymbol = void 0;
|
|
node.locals = void 0;
|
|
node.nextContainer = void 0;
|
|
return node;
|
|
}
|
|
function createBaseNamedDeclaration(kind, modifiers, name) {
|
|
const node = createBaseDeclaration(kind);
|
|
name = asName(name);
|
|
node.name = name;
|
|
if (canHaveModifiers(node)) {
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers);
|
|
}
|
|
if (name) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
if (isIdentifier(name)) {
|
|
node.transformFlags |= propagateIdentifierNameFlags(name);
|
|
break;
|
|
}
|
|
default:
|
|
node.transformFlags |= propagateChildFlags(name);
|
|
break;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function createBaseGenericNamedDeclaration(kind, modifiers, name, typeParameters) {
|
|
const node = createBaseNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.typeParameters = asNodeArray(typeParameters);
|
|
node.transformFlags |= propagateChildrenFlags(node.typeParameters);
|
|
if (typeParameters)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseSignatureDeclaration(kind, modifiers, name, typeParameters, parameters, type) {
|
|
const 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 /* ContainsTypeScript */;
|
|
node.typeArguments = void 0;
|
|
return node;
|
|
}
|
|
function finishUpdateBaseSignatureDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.typeArguments = original.typeArguments;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createBaseFunctionLikeDeclaration(kind, modifiers, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseSignatureDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.body = body;
|
|
node.transformFlags |= propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
if (!body)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseInterfaceOrClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses) {
|
|
const 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) {
|
|
const node = createBaseInterfaceOrClassLikeDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses
|
|
);
|
|
node.members = createNodeArray(members);
|
|
node.transformFlags |= propagateChildrenFlags(node.members);
|
|
return node;
|
|
}
|
|
function createBaseBindingLikeDeclaration(kind, modifiers, name, initializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.initializer = initializer;
|
|
node.transformFlags |= propagateChildFlags(node.initializer);
|
|
return node;
|
|
}
|
|
function createBaseVariableLikeDeclaration(kind, modifiers, name, type, initializer) {
|
|
const node = createBaseBindingLikeDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
initializer
|
|
);
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(type);
|
|
if (type)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseLiteral(kind, text) {
|
|
const node = createBaseToken(kind);
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function createNumericLiteral(value, numericLiteralFlags = 0 /* None */) {
|
|
const node = createBaseLiteral(8 /* NumericLiteral */, typeof value === "number" ? value + "" : value);
|
|
node.numericLiteralFlags = numericLiteralFlags;
|
|
if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createBigIntLiteral(value) {
|
|
const node = createBaseLiteral(9 /* BigIntLiteral */, typeof value === "string" ? value : pseudoBigIntToString(value) + "n");
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function createBaseStringLiteral(text, isSingleQuote) {
|
|
const node = createBaseLiteral(10 /* StringLiteral */, text);
|
|
node.singleQuote = isSingleQuote;
|
|
return node;
|
|
}
|
|
function createStringLiteral(text, isSingleQuote, hasExtendedUnicodeEscape) {
|
|
const node = createBaseStringLiteral(text, isSingleQuote);
|
|
node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
|
|
if (hasExtendedUnicodeEscape)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createStringLiteralFromNode(sourceNode) {
|
|
const node = createBaseStringLiteral(getTextOfIdentifierOrLiteral(sourceNode), void 0);
|
|
node.textSourceNode = sourceNode;
|
|
return node;
|
|
}
|
|
function createRegularExpressionLiteral(text) {
|
|
const node = createBaseLiteral(13 /* RegularExpressionLiteral */, text);
|
|
return node;
|
|
}
|
|
function createLiteralLikeNode(kind, text) {
|
|
switch (kind) {
|
|
case 8 /* NumericLiteral */:
|
|
return createNumericLiteral(text, 0);
|
|
case 9 /* BigIntLiteral */:
|
|
return createBigIntLiteral(text);
|
|
case 10 /* StringLiteral */:
|
|
return createStringLiteral(text, void 0);
|
|
case 11 /* JsxText */:
|
|
return createJsxText(text, false);
|
|
case 12 /* JsxTextAllWhiteSpaces */:
|
|
return createJsxText(text, true);
|
|
case 13 /* RegularExpressionLiteral */:
|
|
return createRegularExpressionLiteral(text);
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return createTemplateLiteralLikeNode(kind, text, void 0, 0);
|
|
}
|
|
}
|
|
function createBaseIdentifier(text, originalKeywordKind) {
|
|
if (originalKeywordKind === void 0 && text) {
|
|
originalKeywordKind = stringToToken(text);
|
|
}
|
|
if (originalKeywordKind === 79 /* Identifier */) {
|
|
originalKeywordKind = void 0;
|
|
}
|
|
const node = baseFactory2.createBaseIdentifierNode(79 /* Identifier */);
|
|
node.originalKeywordKind = originalKeywordKind;
|
|
node.escapedText = escapeLeadingUnderscores(text);
|
|
return node;
|
|
}
|
|
function createBaseGeneratedIdentifier(text, autoGenerateFlags, prefix, suffix) {
|
|
const node = createBaseIdentifier(text, void 0);
|
|
node.autoGenerateFlags = autoGenerateFlags;
|
|
node.autoGenerateId = nextAutoGenerateId;
|
|
node.autoGeneratePrefix = prefix;
|
|
node.autoGenerateSuffix = suffix;
|
|
nextAutoGenerateId++;
|
|
return node;
|
|
}
|
|
function createIdentifier(text, typeArguments, originalKeywordKind, hasExtendedUnicodeEscape) {
|
|
const node = createBaseIdentifier(text, originalKeywordKind);
|
|
if (typeArguments) {
|
|
node.typeArguments = createNodeArray(typeArguments);
|
|
}
|
|
if (node.originalKeywordKind === 133 /* AwaitKeyword */) {
|
|
node.transformFlags |= 67108864 /* ContainsPossibleTopLevelAwait */;
|
|
}
|
|
if (hasExtendedUnicodeEscape) {
|
|
node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateIdentifier(node, typeArguments) {
|
|
return node.typeArguments !== typeArguments ? update(createIdentifier(idText(node), typeArguments), node) : node;
|
|
}
|
|
function createTempVariable(recordTempVariable, reservedInNestedScopes, prefix, suffix) {
|
|
let flags2 = 1 /* Auto */;
|
|
if (reservedInNestedScopes)
|
|
flags2 |= 8 /* ReservedInNestedScopes */;
|
|
const name = createBaseGeneratedIdentifier("", flags2, prefix, suffix);
|
|
if (recordTempVariable) {
|
|
recordTempVariable(name);
|
|
}
|
|
return name;
|
|
}
|
|
function createLoopVariable(reservedInNestedScopes) {
|
|
let flags2 = 2 /* Loop */;
|
|
if (reservedInNestedScopes)
|
|
flags2 |= 8 /* ReservedInNestedScopes */;
|
|
return createBaseGeneratedIdentifier("", flags2, void 0, void 0);
|
|
}
|
|
function createUniqueName(text, flags2 = 0 /* None */, prefix, suffix) {
|
|
Debug.assert(!(flags2 & 7 /* KindMask */), "Argument out of range: flags");
|
|
Debug.assert((flags2 & (16 /* Optimistic */ | 32 /* FileLevel */)) !== 32 /* FileLevel */, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic");
|
|
return createBaseGeneratedIdentifier(text, 3 /* Unique */ | flags2, prefix, suffix);
|
|
}
|
|
function getGeneratedNameForNode(node, flags2 = 0, prefix, suffix) {
|
|
Debug.assert(!(flags2 & 7 /* KindMask */), "Argument out of range: flags");
|
|
const text = !node ? "" : isMemberName(node) ? formatGeneratedName(false, prefix, node, suffix, idText) : `generated@${getNodeId(node)}`;
|
|
if (prefix || suffix)
|
|
flags2 |= 16 /* Optimistic */;
|
|
const name = createBaseGeneratedIdentifier(text, 4 /* Node */ | flags2, prefix, suffix);
|
|
name.original = node;
|
|
return name;
|
|
}
|
|
function createBasePrivateIdentifier(text) {
|
|
const node = baseFactory2.createBasePrivateIdentifierNode(80 /* PrivateIdentifier */);
|
|
node.escapedText = escapeLeadingUnderscores(text);
|
|
node.transformFlags |= 16777216 /* ContainsClassFields */;
|
|
return node;
|
|
}
|
|
function createPrivateIdentifier(text) {
|
|
if (!startsWith(text, "#"))
|
|
Debug.fail("First character of private identifier must be #: " + text);
|
|
return createBasePrivateIdentifier(text);
|
|
}
|
|
function createBaseGeneratedPrivateIdentifier(text, autoGenerateFlags, prefix, suffix) {
|
|
const node = createBasePrivateIdentifier(text);
|
|
node.autoGenerateFlags = autoGenerateFlags;
|
|
node.autoGenerateId = nextAutoGenerateId;
|
|
node.autoGeneratePrefix = prefix;
|
|
node.autoGenerateSuffix = suffix;
|
|
nextAutoGenerateId++;
|
|
return node;
|
|
}
|
|
function createUniquePrivateName(text, prefix, suffix) {
|
|
if (text && !startsWith(text, "#"))
|
|
Debug.fail("First character of private identifier must be #: " + text);
|
|
const autoGenerateFlags = 8 /* ReservedInNestedScopes */ | (text ? 3 /* Unique */ : 1 /* Auto */);
|
|
return createBaseGeneratedPrivateIdentifier(text != null ? text : "", autoGenerateFlags, prefix, suffix);
|
|
}
|
|
function getGeneratedPrivateNameForNode(node, prefix, suffix) {
|
|
const text = isMemberName(node) ? formatGeneratedName(true, prefix, node, suffix, idText) : `#generated@${getNodeId(node)}`;
|
|
const flags2 = prefix || suffix ? 16 /* Optimistic */ : 0 /* None */;
|
|
const name = createBaseGeneratedPrivateIdentifier(text, 4 /* Node */ | flags2, prefix, suffix);
|
|
name.original = node;
|
|
return name;
|
|
}
|
|
function createBaseToken(kind) {
|
|
return baseFactory2.createBaseTokenNode(kind);
|
|
}
|
|
function createToken(token) {
|
|
Debug.assert(token >= 0 /* FirstToken */ && token <= 162 /* LastToken */, "Invalid token");
|
|
Debug.assert(token <= 14 /* FirstTemplateToken */ || token >= 17 /* LastTemplateToken */, "Invalid token. Use 'createTemplateLiteralLikeNode' to create template literals.");
|
|
Debug.assert(token <= 8 /* FirstLiteralToken */ || token >= 14 /* LastLiteralToken */, "Invalid token. Use 'createLiteralLikeNode' to create literals.");
|
|
Debug.assert(token !== 79 /* Identifier */, "Invalid token. Use 'createIdentifier' to create identifiers");
|
|
const node = createBaseToken(token);
|
|
let transformFlags = 0 /* None */;
|
|
switch (token) {
|
|
case 132 /* AsyncKeyword */:
|
|
transformFlags = 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
break;
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 131 /* AnyKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
transformFlags = 1 /* ContainsTypeScript */;
|
|
break;
|
|
case 106 /* SuperKeyword */:
|
|
transformFlags = 1024 /* ContainsES2015 */ | 134217728 /* ContainsLexicalSuper */;
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
transformFlags = 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 127 /* AccessorKeyword */:
|
|
transformFlags = 16777216 /* ContainsClassFields */;
|
|
break;
|
|
case 108 /* ThisKeyword */:
|
|
transformFlags = 16384 /* ContainsLexicalThis */;
|
|
break;
|
|
}
|
|
if (transformFlags) {
|
|
node.transformFlags |= transformFlags;
|
|
}
|
|
return node;
|
|
}
|
|
function createSuper() {
|
|
return createToken(106 /* SuperKeyword */);
|
|
}
|
|
function createThis() {
|
|
return createToken(108 /* ThisKeyword */);
|
|
}
|
|
function createNull() {
|
|
return createToken(104 /* NullKeyword */);
|
|
}
|
|
function createTrue() {
|
|
return createToken(110 /* TrueKeyword */);
|
|
}
|
|
function createFalse() {
|
|
return createToken(95 /* FalseKeyword */);
|
|
}
|
|
function createModifier(kind) {
|
|
return createToken(kind);
|
|
}
|
|
function createModifiersFromModifierFlags(flags2) {
|
|
const result = [];
|
|
if (flags2 & 1 /* Export */)
|
|
result.push(createModifier(93 /* ExportKeyword */));
|
|
if (flags2 & 2 /* Ambient */)
|
|
result.push(createModifier(136 /* DeclareKeyword */));
|
|
if (flags2 & 1024 /* Default */)
|
|
result.push(createModifier(88 /* DefaultKeyword */));
|
|
if (flags2 & 2048 /* Const */)
|
|
result.push(createModifier(85 /* ConstKeyword */));
|
|
if (flags2 & 4 /* Public */)
|
|
result.push(createModifier(123 /* PublicKeyword */));
|
|
if (flags2 & 8 /* Private */)
|
|
result.push(createModifier(121 /* PrivateKeyword */));
|
|
if (flags2 & 16 /* Protected */)
|
|
result.push(createModifier(122 /* ProtectedKeyword */));
|
|
if (flags2 & 256 /* Abstract */)
|
|
result.push(createModifier(126 /* AbstractKeyword */));
|
|
if (flags2 & 32 /* Static */)
|
|
result.push(createModifier(124 /* StaticKeyword */));
|
|
if (flags2 & 16384 /* Override */)
|
|
result.push(createModifier(161 /* OverrideKeyword */));
|
|
if (flags2 & 64 /* Readonly */)
|
|
result.push(createModifier(146 /* ReadonlyKeyword */));
|
|
if (flags2 & 128 /* Accessor */)
|
|
result.push(createModifier(127 /* AccessorKeyword */));
|
|
if (flags2 & 512 /* Async */)
|
|
result.push(createModifier(132 /* AsyncKeyword */));
|
|
if (flags2 & 32768 /* In */)
|
|
result.push(createModifier(101 /* InKeyword */));
|
|
if (flags2 & 65536 /* Out */)
|
|
result.push(createModifier(145 /* OutKeyword */));
|
|
return result.length ? result : void 0;
|
|
}
|
|
function createQualifiedName(left, right) {
|
|
const node = createBaseNode(163 /* QualifiedName */);
|
|
node.left = left;
|
|
node.right = asName(right);
|
|
node.transformFlags |= propagateChildFlags(node.left) | propagateIdentifierNameFlags(node.right);
|
|
return node;
|
|
}
|
|
function updateQualifiedName(node, left, right) {
|
|
return node.left !== left || node.right !== right ? update(createQualifiedName(left, right), node) : node;
|
|
}
|
|
function createComputedPropertyName(expression) {
|
|
const node = createBaseNode(164 /* ComputedPropertyName */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfComputedPropertyName(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1024 /* ContainsES2015 */ | 131072 /* ContainsComputedPropertyName */;
|
|
return node;
|
|
}
|
|
function updateComputedPropertyName(node, expression) {
|
|
return node.expression !== expression ? update(createComputedPropertyName(expression), node) : node;
|
|
}
|
|
function createTypeParameterDeclaration(modifiers, name, constraint, defaultType) {
|
|
const node = createBaseNamedDeclaration(
|
|
165 /* TypeParameter */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.constraint = constraint;
|
|
node.default = defaultType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
166 /* Parameter */,
|
|
modifiers,
|
|
name,
|
|
type,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.questionToken = questionToken;
|
|
if (isThisIdentifier(node.name)) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | propagateChildFlags(node.questionToken);
|
|
if (questionToken)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
if (modifiersToFlags(node.modifiers) & 16476 /* ParameterPropertyModifier */)
|
|
node.transformFlags |= 8192 /* ContainsTypeScriptClassSyntax */;
|
|
if (initializer || dotDotDotToken)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
}
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createDecorator(expression) {
|
|
const node = createBaseNode(167 /* Decorator */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */ | 8192 /* ContainsTypeScriptClassSyntax */ | 33554432 /* ContainsDecorators */;
|
|
return node;
|
|
}
|
|
function updateDecorator(node, expression) {
|
|
return node.expression !== expression ? update(createDecorator(expression), node) : node;
|
|
}
|
|
function createPropertySignature(modifiers, name, questionToken, type) {
|
|
const node = createBaseNamedDeclaration(
|
|
168 /* PropertySignature */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.type = type;
|
|
node.questionToken = questionToken;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.initializer = void 0;
|
|
return node;
|
|
}
|
|
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) {
|
|
updated.initializer = original.initializer;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
169 /* PropertyDeclaration */,
|
|
modifiers,
|
|
name,
|
|
type,
|
|
initializer
|
|
);
|
|
node.questionToken = questionOrExclamationToken && isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
|
|
node.exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
|
|
node.transformFlags |= propagateChildFlags(node.questionToken) | propagateChildFlags(node.exclamationToken) | 16777216 /* ContainsClassFields */;
|
|
if (isComputedPropertyName(node.name) || hasStaticModifier(node) && node.initializer) {
|
|
node.transformFlags |= 8192 /* ContainsTypeScriptClassSyntax */;
|
|
}
|
|
if (questionOrExclamationToken || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePropertyDeclaration(node, modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.questionToken !== (questionOrExclamationToken !== void 0 && isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0) || node.exclamationToken !== (questionOrExclamationToken !== void 0 && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0) || node.type !== type || node.initializer !== initializer ? update(createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer), node) : node;
|
|
}
|
|
function createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
170 /* MethodSignature */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.questionToken = questionToken;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
171 /* MethodDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
node.questionToken = questionToken;
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken) | propagateChildFlags(node.questionToken) | 1024 /* ContainsES2015 */;
|
|
if (questionToken) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createClassStaticBlockDeclaration(body) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
172 /* ClassStaticBlockDeclaration */,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
node.body = body;
|
|
node.transformFlags = propagateChildFlags(body) | 16777216 /* ContainsClassFields */;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createConstructorDeclaration(modifiers, parameters, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
173 /* Constructor */,
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
node.illegalDecorators = void 0;
|
|
node.typeParameters = void 0;
|
|
node.type = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createGetAccessorDeclaration(modifiers, name, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
174 /* GetAccessor */,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.typeParameters = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createSetAccessorDeclaration(modifiers, name, parameters, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
175 /* SetAccessor */,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
node.typeParameters = void 0;
|
|
node.type = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createCallSignature(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
176 /* CallSignature */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateCallSignature(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateBaseSignatureDeclaration(createCallSignature(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function createConstructSignature(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
177 /* ConstructSignature */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateConstructSignature(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateBaseSignatureDeclaration(createConstructSignature(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function createIndexSignature(modifiers, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
178 /* IndexSignature */,
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateIndexSignature(node, modifiers, parameters, type) {
|
|
return node.parameters !== parameters || node.type !== type || node.modifiers !== modifiers ? finishUpdateBaseSignatureDeclaration(createIndexSignature(modifiers, parameters, type), node) : node;
|
|
}
|
|
function createTemplateLiteralTypeSpan(type, literal) {
|
|
const node = createBaseNode(201 /* TemplateLiteralTypeSpan */);
|
|
node.type = type;
|
|
node.literal = literal;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTemplateLiteralTypeSpan(node, type, literal) {
|
|
return node.type !== type || node.literal !== literal ? update(createTemplateLiteralTypeSpan(type, literal), node) : node;
|
|
}
|
|
function createKeywordTypeNode(kind) {
|
|
return createToken(kind);
|
|
}
|
|
function createTypePredicateNode(assertsModifier, parameterName, type) {
|
|
const node = createBaseNode(179 /* TypePredicate */);
|
|
node.assertsModifier = assertsModifier;
|
|
node.parameterName = asName(parameterName);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypePredicateNode(node, assertsModifier, parameterName, type) {
|
|
return node.assertsModifier !== assertsModifier || node.parameterName !== parameterName || node.type !== type ? update(createTypePredicateNode(assertsModifier, parameterName, type), node) : node;
|
|
}
|
|
function createTypeReferenceNode(typeName, typeArguments) {
|
|
const node = createBaseNode(180 /* TypeReference */);
|
|
node.typeName = asName(typeName);
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(createNodeArray(typeArguments));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeReferenceNode(node, typeName, typeArguments) {
|
|
return node.typeName !== typeName || node.typeArguments !== typeArguments ? update(createTypeReferenceNode(typeName, typeArguments), node) : node;
|
|
}
|
|
function createFunctionTypeNode(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
181 /* FunctionType */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createConstructorTypeNode(...args) {
|
|
return args.length === 4 ? createConstructorTypeNode1(...args) : args.length === 3 ? createConstructorTypeNode2(...args) : Debug.fail("Incorrect number of arguments specified.");
|
|
}
|
|
function createConstructorTypeNode1(modifiers, typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
182 /* ConstructorType */,
|
|
modifiers,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createConstructorTypeNode2(typeParameters, parameters, type) {
|
|
return createConstructorTypeNode1(void 0, typeParameters, parameters, type);
|
|
}
|
|
function updateConstructorTypeNode(...args) {
|
|
return args.length === 5 ? updateConstructorTypeNode1(...args) : args.length === 4 ? updateConstructorTypeNode2(...args) : 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;
|
|
}
|
|
function updateConstructorTypeNode2(node, typeParameters, parameters, type) {
|
|
return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type);
|
|
}
|
|
function createTypeQueryNode(exprName, typeArguments) {
|
|
const node = createBaseNode(183 /* TypeQuery */);
|
|
node.exprName = exprName;
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeQueryNode(node, exprName, typeArguments) {
|
|
return node.exprName !== exprName || node.typeArguments !== typeArguments ? update(createTypeQueryNode(exprName, typeArguments), node) : node;
|
|
}
|
|
function createTypeLiteralNode(members) {
|
|
const node = createBaseNode(184 /* TypeLiteral */);
|
|
node.members = createNodeArray(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeLiteralNode(node, members) {
|
|
return node.members !== members ? update(createTypeLiteralNode(members), node) : node;
|
|
}
|
|
function createArrayTypeNode(elementType) {
|
|
const node = createBaseNode(185 /* ArrayType */);
|
|
node.elementType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(elementType);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateArrayTypeNode(node, elementType) {
|
|
return node.elementType !== elementType ? update(createArrayTypeNode(elementType), node) : node;
|
|
}
|
|
function createTupleTypeNode(elements) {
|
|
const node = createBaseNode(186 /* TupleType */);
|
|
node.elements = createNodeArray(parenthesizerRules().parenthesizeElementTypesOfTupleType(elements));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTupleTypeNode(node, elements) {
|
|
return node.elements !== elements ? update(createTupleTypeNode(elements), node) : node;
|
|
}
|
|
function createNamedTupleMember(dotDotDotToken, name, questionToken, type) {
|
|
const node = createBaseNode(199 /* NamedTupleMember */);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.name = name;
|
|
node.questionToken = questionToken;
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createOptionalTypeNode(type) {
|
|
const node = createBaseNode(187 /* OptionalType */);
|
|
node.type = parenthesizerRules().parenthesizeTypeOfOptionalType(type);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateOptionalTypeNode(node, type) {
|
|
return node.type !== type ? update(createOptionalTypeNode(type), node) : node;
|
|
}
|
|
function createRestTypeNode(type) {
|
|
const node = createBaseNode(188 /* RestType */);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateRestTypeNode(node, type) {
|
|
return node.type !== type ? update(createRestTypeNode(type), node) : node;
|
|
}
|
|
function createUnionOrIntersectionTypeNode(kind, types, parenthesize) {
|
|
const node = createBaseNode(kind);
|
|
node.types = factory2.createNodeArray(parenthesize(types));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateUnionOrIntersectionTypeNode(node, types, parenthesize) {
|
|
return node.types !== types ? update(createUnionOrIntersectionTypeNode(node.kind, types, parenthesize), node) : node;
|
|
}
|
|
function createUnionTypeNode(types) {
|
|
return createUnionOrIntersectionTypeNode(189 /* UnionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
|
|
}
|
|
function updateUnionTypeNode(node, types) {
|
|
return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
|
|
}
|
|
function createIntersectionTypeNode(types) {
|
|
return createUnionOrIntersectionTypeNode(190 /* IntersectionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
|
|
}
|
|
function updateIntersectionTypeNode(node, types) {
|
|
return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
|
|
}
|
|
function createConditionalTypeNode(checkType, extendsType, trueType, falseType) {
|
|
const node = createBaseNode(191 /* ConditionalType */);
|
|
node.checkType = parenthesizerRules().parenthesizeCheckTypeOfConditionalType(checkType);
|
|
node.extendsType = parenthesizerRules().parenthesizeExtendsTypeOfConditionalType(extendsType);
|
|
node.trueType = trueType;
|
|
node.falseType = falseType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createInferTypeNode(typeParameter) {
|
|
const node = createBaseNode(192 /* InferType */);
|
|
node.typeParameter = typeParameter;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateInferTypeNode(node, typeParameter) {
|
|
return node.typeParameter !== typeParameter ? update(createInferTypeNode(typeParameter), node) : node;
|
|
}
|
|
function createTemplateLiteralType(head, templateSpans) {
|
|
const node = createBaseNode(200 /* TemplateLiteralType */);
|
|
node.head = head;
|
|
node.templateSpans = createNodeArray(templateSpans);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTemplateLiteralType(node, head, templateSpans) {
|
|
return node.head !== head || node.templateSpans !== templateSpans ? update(createTemplateLiteralType(head, templateSpans), node) : node;
|
|
}
|
|
function createImportTypeNode(argument, assertions, qualifier, typeArguments, isTypeOf = false) {
|
|
const node = createBaseNode(202 /* ImportType */);
|
|
node.argument = argument;
|
|
node.assertions = assertions;
|
|
node.qualifier = qualifier;
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.isTypeOf = isTypeOf;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateImportTypeNode(node, argument, assertions, qualifier, typeArguments, 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;
|
|
}
|
|
function createParenthesizedType(type) {
|
|
const node = createBaseNode(193 /* ParenthesizedType */);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateParenthesizedType(node, type) {
|
|
return node.type !== type ? update(createParenthesizedType(type), node) : node;
|
|
}
|
|
function createThisTypeNode() {
|
|
const node = createBaseNode(194 /* ThisType */);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createTypeOperatorNode(operator, type) {
|
|
const node = createBaseNode(195 /* TypeOperator */);
|
|
node.operator = operator;
|
|
node.type = operator === 146 /* ReadonlyKeyword */ ? parenthesizerRules().parenthesizeOperandOfReadonlyTypeOperator(type) : parenthesizerRules().parenthesizeOperandOfTypeOperator(type);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeOperatorNode(node, type) {
|
|
return node.type !== type ? update(createTypeOperatorNode(node.operator, type), node) : node;
|
|
}
|
|
function createIndexedAccessTypeNode(objectType, indexType) {
|
|
const node = createBaseNode(196 /* IndexedAccessType */);
|
|
node.objectType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(objectType);
|
|
node.indexType = indexType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateIndexedAccessTypeNode(node, objectType, indexType) {
|
|
return node.objectType !== objectType || node.indexType !== indexType ? update(createIndexedAccessTypeNode(objectType, indexType), node) : node;
|
|
}
|
|
function createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members) {
|
|
const node = createBaseNode(197 /* MappedType */);
|
|
node.readonlyToken = readonlyToken;
|
|
node.typeParameter = typeParameter;
|
|
node.nameType = nameType;
|
|
node.questionToken = questionToken;
|
|
node.type = type;
|
|
node.members = members && createNodeArray(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createLiteralTypeNode(literal) {
|
|
const node = createBaseNode(198 /* LiteralType */);
|
|
node.literal = literal;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateLiteralTypeNode(node, literal) {
|
|
return node.literal !== literal ? update(createLiteralTypeNode(literal), node) : node;
|
|
}
|
|
function createObjectBindingPattern(elements) {
|
|
const node = createBaseNode(203 /* ObjectBindingPattern */);
|
|
node.elements = createNodeArray(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements) | 1024 /* ContainsES2015 */ | 524288 /* ContainsBindingPattern */;
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */ | 65536 /* ContainsObjectRestOrSpread */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateObjectBindingPattern(node, elements) {
|
|
return node.elements !== elements ? update(createObjectBindingPattern(elements), node) : node;
|
|
}
|
|
function createArrayBindingPattern(elements) {
|
|
const node = createBaseNode(204 /* ArrayBindingPattern */);
|
|
node.elements = createNodeArray(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements) | 1024 /* ContainsES2015 */ | 524288 /* ContainsBindingPattern */;
|
|
return node;
|
|
}
|
|
function updateArrayBindingPattern(node, elements) {
|
|
return node.elements !== elements ? update(createArrayBindingPattern(elements), node) : node;
|
|
}
|
|
function createBindingElement(dotDotDotToken, propertyName, name, initializer) {
|
|
const node = createBaseBindingLikeDeclaration(
|
|
205 /* BindingElement */,
|
|
void 0,
|
|
name,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.propertyName = asName(propertyName);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | 1024 /* ContainsES2015 */;
|
|
if (node.propertyName) {
|
|
node.transformFlags |= isIdentifier(node.propertyName) ? propagateIdentifierNameFlags(node.propertyName) : propagateChildFlags(node.propertyName);
|
|
}
|
|
if (dotDotDotToken)
|
|
node.transformFlags |= 32768 /* ContainsRestOrSpread */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createBaseExpression(kind) {
|
|
const node = createBaseNode(kind);
|
|
return node;
|
|
}
|
|
function createArrayLiteralExpression(elements, multiLine) {
|
|
const node = createBaseExpression(206 /* ArrayLiteralExpression */);
|
|
const lastElement = elements && lastOrUndefined(elements);
|
|
const elementsArray = createNodeArray(elements, lastElement && isOmittedExpression(lastElement) ? true : void 0);
|
|
node.elements = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(elementsArray);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
return node;
|
|
}
|
|
function updateArrayLiteralExpression(node, elements) {
|
|
return node.elements !== elements ? update(createArrayLiteralExpression(elements, node.multiLine), node) : node;
|
|
}
|
|
function createObjectLiteralExpression(properties, multiLine) {
|
|
const node = createBaseExpression(207 /* ObjectLiteralExpression */);
|
|
node.properties = createNodeArray(properties);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.properties);
|
|
return node;
|
|
}
|
|
function updateObjectLiteralExpression(node, properties) {
|
|
return node.properties !== properties ? update(createObjectLiteralExpression(properties, node.multiLine), node) : node;
|
|
}
|
|
function createPropertyAccessExpression(expression, name) {
|
|
const node = createBaseExpression(208 /* PropertyAccessExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.name = asName(name);
|
|
node.transformFlags = propagateChildFlags(node.expression) | (isIdentifier(node.name) ? propagateIdentifierNameFlags(node.name) : propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
if (isSuperKeyword(expression)) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePropertyAccessExpression(node, expression, name) {
|
|
if (isPropertyAccessChain(node)) {
|
|
return updatePropertyAccessChain(node, expression, node.questionDotToken, cast(name, isIdentifier));
|
|
}
|
|
return node.expression !== expression || node.name !== name ? update(createPropertyAccessExpression(expression, name), node) : node;
|
|
}
|
|
function createPropertyAccessChain(expression, questionDotToken, name) {
|
|
const node = createBaseExpression(208 /* PropertyAccessExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.questionDotToken = questionDotToken;
|
|
node.name = asName(name);
|
|
node.transformFlags |= 32 /* ContainsES2020 */ | propagateChildFlags(node.expression) | propagateChildFlags(node.questionDotToken) | (isIdentifier(node.name) ? propagateIdentifierNameFlags(node.name) : propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
return node;
|
|
}
|
|
function updatePropertyAccessChain(node, expression, questionDotToken, name) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead.");
|
|
return node.expression !== expression || node.questionDotToken !== questionDotToken || node.name !== name ? update(createPropertyAccessChain(expression, questionDotToken, name), node) : node;
|
|
}
|
|
function createElementAccessExpression(expression, index) {
|
|
const node = createBaseExpression(209 /* ElementAccessExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.argumentExpression = asExpression(index);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.argumentExpression);
|
|
if (isSuperKeyword(expression)) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateElementAccessExpression(node, expression, argumentExpression) {
|
|
if (isElementAccessChain(node)) {
|
|
return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression);
|
|
}
|
|
return node.expression !== expression || node.argumentExpression !== argumentExpression ? update(createElementAccessExpression(expression, argumentExpression), node) : node;
|
|
}
|
|
function createElementAccessChain(expression, questionDotToken, index) {
|
|
const node = createBaseExpression(209 /* ElementAccessExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.questionDotToken = questionDotToken;
|
|
node.argumentExpression = asExpression(index);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.questionDotToken) | propagateChildFlags(node.argumentExpression) | 32 /* ContainsES2020 */;
|
|
return node;
|
|
}
|
|
function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead.");
|
|
return node.expression !== expression || node.questionDotToken !== questionDotToken || node.argumentExpression !== argumentExpression ? update(createElementAccessChain(expression, questionDotToken, argumentExpression), node) : node;
|
|
}
|
|
function createCallExpression(expression, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(210 /* CallExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, 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 /* ContainsTypeScript */;
|
|
}
|
|
if (isImportKeyword(node.expression)) {
|
|
node.transformFlags |= 8388608 /* ContainsDynamicImport */;
|
|
} else if (isSuperProperty(node.expression)) {
|
|
node.transformFlags |= 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateCallExpression(node, expression, typeArguments, argumentsArray) {
|
|
if (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;
|
|
}
|
|
function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(210 /* CallExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, 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 /* ContainsES2020 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (isSuperProperty(node.expression)) {
|
|
node.transformFlags |= 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) {
|
|
Debug.assert(!!(node.flags & 32 /* 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;
|
|
}
|
|
function createNewExpression(expression, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(211 /* NewExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfNew(expression);
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.arguments = argumentsArray ? parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(argumentsArray) : void 0;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.typeArguments) | propagateChildrenFlags(node.arguments) | 32 /* ContainsES2020 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateNewExpression(node, expression, typeArguments, argumentsArray) {
|
|
return node.expression !== expression || node.typeArguments !== typeArguments || node.arguments !== argumentsArray ? update(createNewExpression(expression, typeArguments, argumentsArray), node) : node;
|
|
}
|
|
function createTaggedTemplateExpression(tag, typeArguments, template) {
|
|
const node = createBaseExpression(212 /* TaggedTemplateExpression */);
|
|
node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag, false);
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.template = template;
|
|
node.transformFlags |= propagateChildFlags(node.tag) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.template) | 1024 /* ContainsES2015 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (hasInvalidEscape(node.template)) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateTaggedTemplateExpression(node, tag, typeArguments, template) {
|
|
return node.tag !== tag || node.typeArguments !== typeArguments || node.template !== template ? update(createTaggedTemplateExpression(tag, typeArguments, template), node) : node;
|
|
}
|
|
function createTypeAssertion(type, expression) {
|
|
const node = createBaseExpression(213 /* TypeAssertionExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeAssertion(node, type, expression) {
|
|
return node.type !== type || node.expression !== expression ? update(createTypeAssertion(type, expression), node) : node;
|
|
}
|
|
function createParenthesizedExpression(expression) {
|
|
const node = createBaseExpression(214 /* ParenthesizedExpression */);
|
|
node.expression = expression;
|
|
node.transformFlags = propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateParenthesizedExpression(node, expression) {
|
|
return node.expression !== expression ? update(createParenthesizedExpression(expression), node) : node;
|
|
}
|
|
function createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
215 /* FunctionExpression */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken);
|
|
if (node.typeParameters) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (node.asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (node.asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
216 /* ArrowFunction */,
|
|
modifiers,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body)
|
|
);
|
|
node.equalsGreaterThanToken = equalsGreaterThanToken != null ? equalsGreaterThanToken : createToken(38 /* EqualsGreaterThanToken */);
|
|
node.transformFlags |= propagateChildFlags(node.equalsGreaterThanToken) | 1024 /* ContainsES2015 */;
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createDeleteExpression(expression) {
|
|
const node = createBaseExpression(217 /* DeleteExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateDeleteExpression(node, expression) {
|
|
return node.expression !== expression ? update(createDeleteExpression(expression), node) : node;
|
|
}
|
|
function createTypeOfExpression(expression) {
|
|
const node = createBaseExpression(218 /* TypeOfExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateTypeOfExpression(node, expression) {
|
|
return node.expression !== expression ? update(createTypeOfExpression(expression), node) : node;
|
|
}
|
|
function createVoidExpression(expression) {
|
|
const node = createBaseExpression(219 /* VoidExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateVoidExpression(node, expression) {
|
|
return node.expression !== expression ? update(createVoidExpression(expression), node) : node;
|
|
}
|
|
function createAwaitExpression(expression) {
|
|
const node = createBaseExpression(220 /* AwaitExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */ | 2097152 /* ContainsAwait */;
|
|
return node;
|
|
}
|
|
function updateAwaitExpression(node, expression) {
|
|
return node.expression !== expression ? update(createAwaitExpression(expression), node) : node;
|
|
}
|
|
function createPrefixUnaryExpression(operator, operand) {
|
|
const node = createBaseExpression(221 /* PrefixUnaryExpression */);
|
|
node.operator = operator;
|
|
node.operand = parenthesizerRules().parenthesizeOperandOfPrefixUnary(operand);
|
|
node.transformFlags |= propagateChildFlags(node.operand);
|
|
if ((operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand)) {
|
|
node.transformFlags |= 268435456 /* ContainsUpdateExpressionForIdentifier */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePrefixUnaryExpression(node, operand) {
|
|
return node.operand !== operand ? update(createPrefixUnaryExpression(node.operator, operand), node) : node;
|
|
}
|
|
function createPostfixUnaryExpression(operand, operator) {
|
|
const node = createBaseExpression(222 /* PostfixUnaryExpression */);
|
|
node.operator = operator;
|
|
node.operand = parenthesizerRules().parenthesizeOperandOfPostfixUnary(operand);
|
|
node.transformFlags |= propagateChildFlags(node.operand);
|
|
if (isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand)) {
|
|
node.transformFlags |= 268435456 /* ContainsUpdateExpressionForIdentifier */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePostfixUnaryExpression(node, operand) {
|
|
return node.operand !== operand ? update(createPostfixUnaryExpression(operand, node.operator), node) : node;
|
|
}
|
|
function createBinaryExpression(left, operator, right) {
|
|
const node = createBaseExpression(223 /* BinaryExpression */);
|
|
const operatorToken = asToken(operator);
|
|
const 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 /* QuestionQuestionToken */) {
|
|
node.transformFlags |= 32 /* ContainsES2020 */;
|
|
} else if (operatorKind === 63 /* EqualsToken */) {
|
|
if (isObjectLiteralExpression(node.left)) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 128 /* ContainsES2018 */ | 4096 /* ContainsDestructuringAssignment */ | propagateAssignmentPatternFlags(node.left);
|
|
} else if (isArrayLiteralExpression(node.left)) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 4096 /* ContainsDestructuringAssignment */ | propagateAssignmentPatternFlags(node.left);
|
|
}
|
|
} else if (operatorKind === 42 /* AsteriskAsteriskToken */ || operatorKind === 67 /* AsteriskAsteriskEqualsToken */) {
|
|
node.transformFlags |= 512 /* ContainsES2016 */;
|
|
} else if (isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
|
|
node.transformFlags |= 16 /* ContainsES2021 */;
|
|
}
|
|
if (operatorKind === 101 /* InKeyword */ && isPrivateIdentifier(node.left)) {
|
|
node.transformFlags |= 536870912 /* ContainsPrivateIdentifierInExpression */;
|
|
}
|
|
return node;
|
|
}
|
|
function propagateAssignmentPatternFlags(node) {
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
|
|
return 65536 /* ContainsObjectRestOrSpread */;
|
|
if (node.transformFlags & 128 /* ContainsES2018 */) {
|
|
for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (target && isAssignmentPattern(target)) {
|
|
if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return 65536 /* ContainsObjectRestOrSpread */;
|
|
}
|
|
if (target.transformFlags & 128 /* ContainsES2018 */) {
|
|
const flags2 = propagateAssignmentPatternFlags(target);
|
|
if (flags2)
|
|
return flags2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function updateBinaryExpression(node, left, operator, right) {
|
|
return node.left !== left || node.operatorToken !== operator || node.right !== right ? update(createBinaryExpression(left, operator, right), node) : node;
|
|
}
|
|
function createConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse) {
|
|
const node = createBaseExpression(224 /* ConditionalExpression */);
|
|
node.condition = parenthesizerRules().parenthesizeConditionOfConditionalExpression(condition);
|
|
node.questionToken = questionToken != null ? questionToken : createToken(57 /* QuestionToken */);
|
|
node.whenTrue = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenTrue);
|
|
node.colonToken = colonToken != null ? colonToken : createToken(58 /* 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;
|
|
}
|
|
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;
|
|
}
|
|
function createTemplateExpression(head, templateSpans) {
|
|
const node = createBaseExpression(225 /* TemplateExpression */);
|
|
node.head = head;
|
|
node.templateSpans = createNodeArray(templateSpans);
|
|
node.transformFlags |= propagateChildFlags(node.head) | propagateChildrenFlags(node.templateSpans) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateTemplateExpression(node, head, templateSpans) {
|
|
return node.head !== head || node.templateSpans !== templateSpans ? update(createTemplateExpression(head, templateSpans), node) : node;
|
|
}
|
|
function createTemplateLiteralLikeNodeChecked(kind, text, rawText, templateFlags = 0 /* None */) {
|
|
Debug.assert(!(templateFlags & ~2048 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
|
|
let cooked = void 0;
|
|
if (rawText !== void 0 && rawText !== text) {
|
|
cooked = getCookedText(kind, rawText);
|
|
if (typeof cooked === "object") {
|
|
return Debug.fail("Invalid raw text");
|
|
}
|
|
}
|
|
if (text === void 0) {
|
|
if (cooked === void 0) {
|
|
return Debug.fail("Arguments 'text' and 'rawText' may not both be undefined.");
|
|
}
|
|
text = cooked;
|
|
} else if (cooked !== void 0) {
|
|
Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'.");
|
|
}
|
|
return createTemplateLiteralLikeNode(kind, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateLiteralLikeNode(kind, text, rawText, templateFlags) {
|
|
const node = createBaseToken(kind);
|
|
node.text = text;
|
|
node.rawText = rawText;
|
|
node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
if (node.templateFlags) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function createTemplateHead(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(15 /* TemplateHead */, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateMiddle(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(16 /* TemplateMiddle */, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateTail(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(17 /* TemplateTail */, text, rawText, templateFlags);
|
|
}
|
|
function createNoSubstitutionTemplateLiteral(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(14 /* NoSubstitutionTemplateLiteral */, text, rawText, templateFlags);
|
|
}
|
|
function createYieldExpression(asteriskToken, expression) {
|
|
Debug.assert(!asteriskToken || !!expression, "A `YieldExpression` with an asteriskToken must have an expression.");
|
|
const node = createBaseExpression(226 /* YieldExpression */);
|
|
node.expression = expression && parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.asteriskToken = asteriskToken;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.asteriskToken) | 1024 /* ContainsES2015 */ | 128 /* ContainsES2018 */ | 1048576 /* ContainsYield */;
|
|
return node;
|
|
}
|
|
function updateYieldExpression(node, asteriskToken, expression) {
|
|
return node.expression !== expression || node.asteriskToken !== asteriskToken ? update(createYieldExpression(asteriskToken, expression), node) : node;
|
|
}
|
|
function createSpreadElement(expression) {
|
|
const node = createBaseExpression(227 /* SpreadElement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1024 /* ContainsES2015 */ | 32768 /* ContainsRestOrSpread */;
|
|
return node;
|
|
}
|
|
function updateSpreadElement(node, expression) {
|
|
return node.expression !== expression ? update(createSpreadElement(expression), node) : node;
|
|
}
|
|
function createClassExpression(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseClassLikeDeclaration(
|
|
228 /* ClassExpression */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createOmittedExpression() {
|
|
return createBaseExpression(229 /* OmittedExpression */);
|
|
}
|
|
function createExpressionWithTypeArguments(expression, typeArguments) {
|
|
const node = createBaseNode(230 /* ExpressionWithTypeArguments */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.typeArguments) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateExpressionWithTypeArguments(node, expression, typeArguments) {
|
|
return node.expression !== expression || node.typeArguments !== typeArguments ? update(createExpressionWithTypeArguments(expression, typeArguments), node) : node;
|
|
}
|
|
function createAsExpression(expression, type) {
|
|
const node = createBaseExpression(231 /* AsExpression */);
|
|
node.expression = expression;
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateAsExpression(node, expression, type) {
|
|
return node.expression !== expression || node.type !== type ? update(createAsExpression(expression, type), node) : node;
|
|
}
|
|
function createNonNullExpression(expression) {
|
|
const node = createBaseExpression(232 /* NonNullExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateNonNullExpression(node, expression) {
|
|
if (isNonNullChain(node)) {
|
|
return updateNonNullChain(node, expression);
|
|
}
|
|
return node.expression !== expression ? update(createNonNullExpression(expression), node) : node;
|
|
}
|
|
function createSatisfiesExpression(expression, type) {
|
|
const node = createBaseExpression(235 /* SatisfiesExpression */);
|
|
node.expression = expression;
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateSatisfiesExpression(node, expression, type) {
|
|
return node.expression !== expression || node.type !== type ? update(createSatisfiesExpression(expression, type), node) : node;
|
|
}
|
|
function createNonNullChain(expression) {
|
|
const node = createBaseExpression(232 /* NonNullExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateNonNullChain(node, expression) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead.");
|
|
return node.expression !== expression ? update(createNonNullChain(expression), node) : node;
|
|
}
|
|
function createMetaProperty(keywordToken, name) {
|
|
const node = createBaseExpression(233 /* MetaProperty */);
|
|
node.keywordToken = keywordToken;
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name);
|
|
switch (keywordToken) {
|
|
case 103 /* NewKeyword */:
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 100 /* ImportKeyword */:
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
break;
|
|
default:
|
|
return Debug.assertNever(keywordToken);
|
|
}
|
|
return node;
|
|
}
|
|
function updateMetaProperty(node, name) {
|
|
return node.name !== name ? update(createMetaProperty(node.keywordToken, name), node) : node;
|
|
}
|
|
function createTemplateSpan(expression, literal) {
|
|
const node = createBaseNode(236 /* TemplateSpan */);
|
|
node.expression = expression;
|
|
node.literal = literal;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.literal) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateTemplateSpan(node, expression, literal) {
|
|
return node.expression !== expression || node.literal !== literal ? update(createTemplateSpan(expression, literal), node) : node;
|
|
}
|
|
function createSemicolonClassElement() {
|
|
const node = createBaseNode(237 /* SemicolonClassElement */);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createBlock(statements, multiLine) {
|
|
const node = createBaseNode(238 /* Block */);
|
|
node.statements = createNodeArray(statements);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateBlock(node, statements) {
|
|
return node.statements !== statements ? update(createBlock(statements, node.multiLine), node) : node;
|
|
}
|
|
function createVariableStatement(modifiers, declarationList) {
|
|
const node = createBaseDeclaration(240 /* VariableStatement */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.declarationList = isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.declarationList);
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateVariableStatement(node, modifiers, declarationList) {
|
|
return node.modifiers !== modifiers || node.declarationList !== declarationList ? update(createVariableStatement(modifiers, declarationList), node) : node;
|
|
}
|
|
function createEmptyStatement() {
|
|
return createBaseNode(239 /* EmptyStatement */);
|
|
}
|
|
function createExpressionStatement(expression) {
|
|
const node = createBaseNode(241 /* ExpressionStatement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfExpressionStatement(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateExpressionStatement(node, expression) {
|
|
return node.expression !== expression ? update(createExpressionStatement(expression), node) : node;
|
|
}
|
|
function createIfStatement(expression, thenStatement, elseStatement) {
|
|
const node = createBaseNode(242 /* 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;
|
|
}
|
|
function updateIfStatement(node, expression, thenStatement, elseStatement) {
|
|
return node.expression !== expression || node.thenStatement !== thenStatement || node.elseStatement !== elseStatement ? update(createIfStatement(expression, thenStatement, elseStatement), node) : node;
|
|
}
|
|
function createDoStatement(statement, expression) {
|
|
const node = createBaseNode(243 /* DoStatement */);
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.statement) | propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateDoStatement(node, statement, expression) {
|
|
return node.statement !== statement || node.expression !== expression ? update(createDoStatement(statement, expression), node) : node;
|
|
}
|
|
function createWhileStatement(expression, statement) {
|
|
const node = createBaseNode(244 /* WhileStatement */);
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateWhileStatement(node, expression, statement) {
|
|
return node.expression !== expression || node.statement !== statement ? update(createWhileStatement(expression, statement), node) : node;
|
|
}
|
|
function createForStatement(initializer, condition, incrementor, statement) {
|
|
const node = createBaseNode(245 /* 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;
|
|
}
|
|
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;
|
|
}
|
|
function createForInStatement(initializer, expression, statement) {
|
|
const node = createBaseNode(246 /* ForInStatement */);
|
|
node.initializer = initializer;
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.initializer) | propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateForInStatement(node, initializer, expression, statement) {
|
|
return node.initializer !== initializer || node.expression !== expression || node.statement !== statement ? update(createForInStatement(initializer, expression, statement), node) : node;
|
|
}
|
|
function createForOfStatement(awaitModifier, initializer, expression, statement) {
|
|
const node = createBaseNode(247 /* 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 /* ContainsES2015 */;
|
|
if (awaitModifier)
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createContinueStatement(label) {
|
|
const node = createBaseNode(248 /* ContinueStatement */);
|
|
node.label = asName(label);
|
|
node.transformFlags |= propagateChildFlags(node.label) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateContinueStatement(node, label) {
|
|
return node.label !== label ? update(createContinueStatement(label), node) : node;
|
|
}
|
|
function createBreakStatement(label) {
|
|
const node = createBaseNode(249 /* BreakStatement */);
|
|
node.label = asName(label);
|
|
node.transformFlags |= propagateChildFlags(node.label) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateBreakStatement(node, label) {
|
|
return node.label !== label ? update(createBreakStatement(label), node) : node;
|
|
}
|
|
function createReturnStatement(expression) {
|
|
const node = createBaseNode(250 /* ReturnStatement */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 128 /* ContainsES2018 */ | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateReturnStatement(node, expression) {
|
|
return node.expression !== expression ? update(createReturnStatement(expression), node) : node;
|
|
}
|
|
function createWithStatement(expression, statement) {
|
|
const node = createBaseNode(251 /* WithStatement */);
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateWithStatement(node, expression, statement) {
|
|
return node.expression !== expression || node.statement !== statement ? update(createWithStatement(expression, statement), node) : node;
|
|
}
|
|
function createSwitchStatement(expression, caseBlock) {
|
|
const node = createBaseNode(252 /* SwitchStatement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.caseBlock = caseBlock;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.caseBlock);
|
|
return node;
|
|
}
|
|
function updateSwitchStatement(node, expression, caseBlock) {
|
|
return node.expression !== expression || node.caseBlock !== caseBlock ? update(createSwitchStatement(expression, caseBlock), node) : node;
|
|
}
|
|
function createLabeledStatement(label, statement) {
|
|
const node = createBaseNode(253 /* LabeledStatement */);
|
|
node.label = asName(label);
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.label) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateLabeledStatement(node, label, statement) {
|
|
return node.label !== label || node.statement !== statement ? update(createLabeledStatement(label, statement), node) : node;
|
|
}
|
|
function createThrowStatement(expression) {
|
|
const node = createBaseNode(254 /* ThrowStatement */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateThrowStatement(node, expression) {
|
|
return node.expression !== expression ? update(createThrowStatement(expression), node) : node;
|
|
}
|
|
function createTryStatement(tryBlock, catchClause, finallyBlock) {
|
|
const node = createBaseNode(255 /* TryStatement */);
|
|
node.tryBlock = tryBlock;
|
|
node.catchClause = catchClause;
|
|
node.finallyBlock = finallyBlock;
|
|
node.transformFlags |= propagateChildFlags(node.tryBlock) | propagateChildFlags(node.catchClause) | propagateChildFlags(node.finallyBlock);
|
|
return node;
|
|
}
|
|
function updateTryStatement(node, tryBlock, catchClause, finallyBlock) {
|
|
return node.tryBlock !== tryBlock || node.catchClause !== catchClause || node.finallyBlock !== finallyBlock ? update(createTryStatement(tryBlock, catchClause, finallyBlock), node) : node;
|
|
}
|
|
function createDebuggerStatement() {
|
|
return createBaseNode(256 /* DebuggerStatement */);
|
|
}
|
|
function createVariableDeclaration(name, exclamationToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
257 /* VariableDeclaration */,
|
|
void 0,
|
|
name,
|
|
type,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.exclamationToken = exclamationToken;
|
|
node.transformFlags |= propagateChildFlags(node.exclamationToken);
|
|
if (exclamationToken) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createVariableDeclarationList(declarations, flags2 = 0 /* None */) {
|
|
const node = createBaseNode(258 /* VariableDeclarationList */);
|
|
node.flags |= flags2 & 3 /* BlockScoped */;
|
|
node.declarations = createNodeArray(declarations);
|
|
node.transformFlags |= propagateChildrenFlags(node.declarations) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
if (flags2 & 3 /* BlockScoped */) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 262144 /* ContainsBlockScopedBinding */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateVariableDeclarationList(node, declarations) {
|
|
return node.declarations !== declarations ? update(createVariableDeclarationList(declarations, node.flags), node) : node;
|
|
}
|
|
function createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
259 /* FunctionDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
if (!node.body || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (node.asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (node.asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
}
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createClassDeclaration(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseClassLikeDeclaration(
|
|
260 /* ClassDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
if (node.transformFlags & 8192 /* ContainsTypeScriptClassSyntax */) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
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;
|
|
}
|
|
function createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseInterfaceOrClassLikeDeclaration(
|
|
261 /* InterfaceDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses
|
|
);
|
|
node.members = createNodeArray(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createTypeAliasDeclaration(modifiers, name, typeParameters, type) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
262 /* TypeAliasDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters
|
|
);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createEnumDeclaration(modifiers, name, members) {
|
|
const node = createBaseNamedDeclaration(
|
|
263 /* EnumDeclaration */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.members = createNodeArray(members);
|
|
node.transformFlags |= propagateChildrenFlags(node.members) | 1 /* ContainsTypeScript */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createModuleDeclaration(modifiers, name, body, flags2 = 0 /* None */) {
|
|
const node = createBaseDeclaration(264 /* ModuleDeclaration */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.flags |= flags2 & (16 /* Namespace */ | 4 /* NestedNamespace */ | 1024 /* GlobalAugmentation */);
|
|
node.name = name;
|
|
node.body = body;
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.name) | propagateChildFlags(node.body) | 1 /* ContainsTypeScript */;
|
|
}
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createModuleBlock(statements) {
|
|
const node = createBaseNode(265 /* ModuleBlock */);
|
|
node.statements = createNodeArray(statements);
|
|
node.transformFlags |= propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateModuleBlock(node, statements) {
|
|
return node.statements !== statements ? update(createModuleBlock(statements), node) : node;
|
|
}
|
|
function createCaseBlock(clauses) {
|
|
const node = createBaseNode(266 /* CaseBlock */);
|
|
node.clauses = createNodeArray(clauses);
|
|
node.transformFlags |= propagateChildrenFlags(node.clauses);
|
|
return node;
|
|
}
|
|
function updateCaseBlock(node, clauses) {
|
|
return node.clauses !== clauses ? update(createCaseBlock(clauses), node) : node;
|
|
}
|
|
function createNamespaceExportDeclaration(name) {
|
|
const node = createBaseNamedDeclaration(
|
|
267 /* NamespaceExportDeclaration */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference) {
|
|
const node = createBaseNamedDeclaration(
|
|
268 /* ImportEqualsDeclaration */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.moduleReference = moduleReference;
|
|
node.transformFlags |= propagateChildFlags(node.moduleReference);
|
|
if (!isExternalModuleReference(node.moduleReference))
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause) {
|
|
const node = createBaseDeclaration(269 /* 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 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createImportClause(isTypeOnly, name, namedBindings) {
|
|
const node = createBaseNode(270 /* ImportClause */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.name = name;
|
|
node.namedBindings = namedBindings;
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.namedBindings);
|
|
if (isTypeOnly) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateImportClause(node, isTypeOnly, name, namedBindings) {
|
|
return node.isTypeOnly !== isTypeOnly || node.name !== name || node.namedBindings !== namedBindings ? update(createImportClause(isTypeOnly, name, namedBindings), node) : node;
|
|
}
|
|
function createAssertClause(elements, multiLine) {
|
|
const node = createBaseNode(296 /* AssertClause */);
|
|
node.elements = createNodeArray(elements);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function updateAssertClause(node, elements, multiLine) {
|
|
return node.elements !== elements || node.multiLine !== multiLine ? update(createAssertClause(elements, multiLine), node) : node;
|
|
}
|
|
function createAssertEntry(name, value) {
|
|
const node = createBaseNode(297 /* AssertEntry */);
|
|
node.name = name;
|
|
node.value = value;
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function updateAssertEntry(node, name, value) {
|
|
return node.name !== name || node.value !== value ? update(createAssertEntry(name, value), node) : node;
|
|
}
|
|
function createImportTypeAssertionContainer(clause, multiLine) {
|
|
const node = createBaseNode(298 /* ImportTypeAssertionContainer */);
|
|
node.assertClause = clause;
|
|
node.multiLine = multiLine;
|
|
return node;
|
|
}
|
|
function updateImportTypeAssertionContainer(node, clause, multiLine) {
|
|
return node.assertClause !== clause || node.multiLine !== multiLine ? update(createImportTypeAssertionContainer(clause, multiLine), node) : node;
|
|
}
|
|
function createNamespaceImport(name) {
|
|
const node = createBaseNode(271 /* NamespaceImport */);
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamespaceImport(node, name) {
|
|
return node.name !== name ? update(createNamespaceImport(name), node) : node;
|
|
}
|
|
function createNamespaceExport(name) {
|
|
const node = createBaseNode(277 /* NamespaceExport */);
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name) | 4 /* ContainsESNext */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamespaceExport(node, name) {
|
|
return node.name !== name ? update(createNamespaceExport(name), node) : node;
|
|
}
|
|
function createNamedImports(elements) {
|
|
const node = createBaseNode(272 /* NamedImports */);
|
|
node.elements = createNodeArray(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamedImports(node, elements) {
|
|
return node.elements !== elements ? update(createNamedImports(elements), node) : node;
|
|
}
|
|
function createImportSpecifier(isTypeOnly, propertyName, name) {
|
|
const node = createBaseNode(273 /* ImportSpecifier */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.propertyName = propertyName;
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.propertyName) | propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateImportSpecifier(node, isTypeOnly, propertyName, name) {
|
|
return node.isTypeOnly !== isTypeOnly || node.propertyName !== propertyName || node.name !== name ? update(createImportSpecifier(isTypeOnly, propertyName, name), node) : node;
|
|
}
|
|
function createExportAssignment(modifiers, isExportEquals, expression) {
|
|
const node = createBaseDeclaration(274 /* ExportAssignment */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.isExportEquals = isExportEquals;
|
|
node.expression = isExportEquals ? parenthesizerRules().parenthesizeRightSideOfBinary(63 /* EqualsToken */, void 0, expression) : parenthesizerRules().parenthesizeExpressionOfExportDefault(expression);
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.expression);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
const node = createBaseDeclaration(275 /* 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 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
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);
|
|
}
|
|
function createNamedExports(elements) {
|
|
const node = createBaseNode(276 /* NamedExports */);
|
|
node.elements = createNodeArray(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamedExports(node, elements) {
|
|
return node.elements !== elements ? update(createNamedExports(elements), node) : node;
|
|
}
|
|
function createExportSpecifier(isTypeOnly, propertyName, name) {
|
|
const node = createBaseNode(278 /* ExportSpecifier */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.propertyName = asName(propertyName);
|
|
node.name = asName(name);
|
|
node.transformFlags |= propagateChildFlags(node.propertyName) | propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateExportSpecifier(node, isTypeOnly, propertyName, name) {
|
|
return node.isTypeOnly !== isTypeOnly || node.propertyName !== propertyName || node.name !== name ? update(createExportSpecifier(isTypeOnly, propertyName, name), node) : node;
|
|
}
|
|
function createMissingDeclaration() {
|
|
const node = createBaseDeclaration(279 /* MissingDeclaration */);
|
|
return node;
|
|
}
|
|
function createExternalModuleReference(expression) {
|
|
const node = createBaseNode(280 /* ExternalModuleReference */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateExternalModuleReference(node, expression) {
|
|
return node.expression !== expression ? update(createExternalModuleReference(expression), node) : node;
|
|
}
|
|
function createJSDocPrimaryTypeWorker(kind) {
|
|
return createBaseNode(kind);
|
|
}
|
|
function createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix = false) {
|
|
const node = createJSDocUnaryTypeWorker(
|
|
kind,
|
|
postfix ? type && parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(type) : type
|
|
);
|
|
node.postfix = postfix;
|
|
return node;
|
|
}
|
|
function createJSDocUnaryTypeWorker(kind, type) {
|
|
const node = createBaseNode(kind);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
function updateJSDocPrePostfixUnaryTypeWorker(kind, node, type) {
|
|
return node.type !== type ? update(createJSDocPrePostfixUnaryTypeWorker(kind, type, node.postfix), node) : node;
|
|
}
|
|
function updateJSDocUnaryTypeWorker(kind, node, type) {
|
|
return node.type !== type ? update(createJSDocUnaryTypeWorker(kind, type), node) : node;
|
|
}
|
|
function createJSDocFunctionType(parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
320 /* JSDocFunctionType */,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
type
|
|
);
|
|
return node;
|
|
}
|
|
function updateJSDocFunctionType(node, parameters, type) {
|
|
return node.parameters !== parameters || node.type !== type ? update(createJSDocFunctionType(parameters, type), node) : node;
|
|
}
|
|
function createJSDocTypeLiteral(propertyTags, isArrayType = false) {
|
|
const node = createBaseNode(325 /* JSDocTypeLiteral */);
|
|
node.jsDocPropertyTags = asNodeArray(propertyTags);
|
|
node.isArrayType = isArrayType;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeLiteral(node, propertyTags, isArrayType) {
|
|
return node.jsDocPropertyTags !== propertyTags || node.isArrayType !== isArrayType ? update(createJSDocTypeLiteral(propertyTags, isArrayType), node) : node;
|
|
}
|
|
function createJSDocTypeExpression(type) {
|
|
const node = createBaseNode(312 /* JSDocTypeExpression */);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeExpression(node, type) {
|
|
return node.type !== type ? update(createJSDocTypeExpression(type), node) : node;
|
|
}
|
|
function createJSDocSignature(typeParameters, parameters, type) {
|
|
const node = createBaseNode(326 /* JSDocSignature */);
|
|
node.typeParameters = asNodeArray(typeParameters);
|
|
node.parameters = createNodeArray(parameters);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
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) {
|
|
const defaultTagName = getDefaultTagNameForKind(node.kind);
|
|
return node.tagName.escapedText === escapeLeadingUnderscores(defaultTagName) ? node.tagName : createIdentifier(defaultTagName);
|
|
}
|
|
function createBaseJSDocTag(kind, tagName, comment) {
|
|
const node = createBaseNode(kind);
|
|
node.tagName = tagName;
|
|
node.comment = comment;
|
|
return node;
|
|
}
|
|
function createJSDocTemplateTag(tagName, constraint, typeParameters, comment) {
|
|
const node = createBaseJSDocTag(347 /* JSDocTemplateTag */, tagName != null ? tagName : createIdentifier("template"), comment);
|
|
node.constraint = constraint;
|
|
node.typeParameters = createNodeArray(typeParameters);
|
|
return node;
|
|
}
|
|
function updateJSDocTemplateTag(node, tagName = getDefaultTagName(node), constraint, typeParameters, comment) {
|
|
return node.tagName !== tagName || node.constraint !== constraint || node.typeParameters !== typeParameters || node.comment !== comment ? update(createJSDocTemplateTag(tagName, constraint, typeParameters, comment), node) : node;
|
|
}
|
|
function createJSDocTypedefTag(tagName, typeExpression, fullName, comment) {
|
|
const node = createBaseJSDocTag(348 /* JSDocTypedefTag */, tagName != null ? tagName : createIdentifier("typedef"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.fullName = fullName;
|
|
node.name = getJSDocTypeAliasName(fullName);
|
|
return node;
|
|
}
|
|
function updateJSDocTypedefTag(node, tagName = getDefaultTagName(node), typeExpression, fullName, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.fullName !== fullName || node.comment !== comment ? update(createJSDocTypedefTag(tagName, typeExpression, fullName, comment), node) : node;
|
|
}
|
|
function createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
const node = createBaseJSDocTag(343 /* JSDocParameterTag */, tagName != null ? tagName : createIdentifier("param"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.name = name;
|
|
node.isNameFirst = !!isNameFirst;
|
|
node.isBracketed = isBracketed;
|
|
return node;
|
|
}
|
|
function updateJSDocParameterTag(node, tagName = getDefaultTagName(node), name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
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;
|
|
}
|
|
function createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
const node = createBaseJSDocTag(350 /* JSDocPropertyTag */, tagName != null ? tagName : createIdentifier("prop"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.name = name;
|
|
node.isNameFirst = !!isNameFirst;
|
|
node.isBracketed = isBracketed;
|
|
return node;
|
|
}
|
|
function updateJSDocPropertyTag(node, tagName = getDefaultTagName(node), name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
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;
|
|
}
|
|
function createJSDocCallbackTag(tagName, typeExpression, fullName, comment) {
|
|
const node = createBaseJSDocTag(341 /* JSDocCallbackTag */, tagName != null ? tagName : createIdentifier("callback"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.fullName = fullName;
|
|
node.name = getJSDocTypeAliasName(fullName);
|
|
return node;
|
|
}
|
|
function updateJSDocCallbackTag(node, tagName = getDefaultTagName(node), typeExpression, fullName, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.fullName !== fullName || node.comment !== comment ? update(createJSDocCallbackTag(tagName, typeExpression, fullName, comment), node) : node;
|
|
}
|
|
function createJSDocAugmentsTag(tagName, className, comment) {
|
|
const node = createBaseJSDocTag(331 /* JSDocAugmentsTag */, tagName != null ? tagName : createIdentifier("augments"), comment);
|
|
node.class = className;
|
|
return node;
|
|
}
|
|
function updateJSDocAugmentsTag(node, tagName = getDefaultTagName(node), className, comment) {
|
|
return node.tagName !== tagName || node.class !== className || node.comment !== comment ? update(createJSDocAugmentsTag(tagName, className, comment), node) : node;
|
|
}
|
|
function createJSDocImplementsTag(tagName, className, comment) {
|
|
const node = createBaseJSDocTag(332 /* JSDocImplementsTag */, tagName != null ? tagName : createIdentifier("implements"), comment);
|
|
node.class = className;
|
|
return node;
|
|
}
|
|
function createJSDocSeeTag(tagName, name, comment) {
|
|
const node = createBaseJSDocTag(349 /* JSDocSeeTag */, tagName != null ? tagName : createIdentifier("see"), comment);
|
|
node.name = name;
|
|
return node;
|
|
}
|
|
function updateJSDocSeeTag(node, tagName, name, comment) {
|
|
return node.tagName !== tagName || node.name !== name || node.comment !== comment ? update(createJSDocSeeTag(tagName, name, comment), node) : node;
|
|
}
|
|
function createJSDocNameReference(name) {
|
|
const node = createBaseNode(313 /* JSDocNameReference */);
|
|
node.name = name;
|
|
return node;
|
|
}
|
|
function updateJSDocNameReference(node, name) {
|
|
return node.name !== name ? update(createJSDocNameReference(name), node) : node;
|
|
}
|
|
function createJSDocMemberName(left, right) {
|
|
const node = createBaseNode(314 /* JSDocMemberName */);
|
|
node.left = left;
|
|
node.right = right;
|
|
node.transformFlags |= propagateChildFlags(node.left) | propagateChildFlags(node.right);
|
|
return node;
|
|
}
|
|
function updateJSDocMemberName(node, left, right) {
|
|
return node.left !== left || node.right !== right ? update(createJSDocMemberName(left, right), node) : node;
|
|
}
|
|
function createJSDocLink(name, text) {
|
|
const node = createBaseNode(327 /* JSDocLink */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLink(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLink(name, text), node) : node;
|
|
}
|
|
function createJSDocLinkCode(name, text) {
|
|
const node = createBaseNode(328 /* JSDocLinkCode */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLinkCode(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLinkCode(name, text), node) : node;
|
|
}
|
|
function createJSDocLinkPlain(name, text) {
|
|
const node = createBaseNode(329 /* JSDocLinkPlain */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLinkPlain(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLinkPlain(name, text), node) : node;
|
|
}
|
|
function updateJSDocImplementsTag(node, tagName = getDefaultTagName(node), className, comment) {
|
|
return node.tagName !== tagName || node.class !== className || node.comment !== comment ? update(createJSDocImplementsTag(tagName, className, comment), node) : node;
|
|
}
|
|
function createJSDocSimpleTagWorker(kind, tagName, comment) {
|
|
const node = createBaseJSDocTag(kind, tagName != null ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment);
|
|
return node;
|
|
}
|
|
function updateJSDocSimpleTagWorker(kind, node, tagName = getDefaultTagName(node), comment) {
|
|
return node.tagName !== tagName || node.comment !== comment ? update(createJSDocSimpleTagWorker(kind, tagName, comment), node) : node;
|
|
}
|
|
function createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment) {
|
|
const node = createBaseJSDocTag(kind, tagName != null ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment);
|
|
node.typeExpression = typeExpression;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeLikeTagWorker(kind, node, tagName = getDefaultTagName(node), typeExpression, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.comment !== comment ? update(createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment), node) : node;
|
|
}
|
|
function createJSDocUnknownTag(tagName, comment) {
|
|
const node = createBaseJSDocTag(330 /* JSDocTag */, tagName, comment);
|
|
return node;
|
|
}
|
|
function updateJSDocUnknownTag(node, tagName, comment) {
|
|
return node.tagName !== tagName || node.comment !== comment ? update(createJSDocUnknownTag(tagName, comment), node) : node;
|
|
}
|
|
function createJSDocText(text) {
|
|
const node = createBaseNode(324 /* JSDocText */);
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocText(node, text) {
|
|
return node.text !== text ? update(createJSDocText(text), node) : node;
|
|
}
|
|
function createJSDocComment(comment, tags) {
|
|
const node = createBaseNode(323 /* JSDoc */);
|
|
node.comment = comment;
|
|
node.tags = asNodeArray(tags);
|
|
return node;
|
|
}
|
|
function updateJSDocComment(node, comment, tags) {
|
|
return node.comment !== comment || node.tags !== tags ? update(createJSDocComment(comment, tags), node) : node;
|
|
}
|
|
function createJsxElement(openingElement, children, closingElement) {
|
|
const node = createBaseNode(281 /* JsxElement */);
|
|
node.openingElement = openingElement;
|
|
node.children = createNodeArray(children);
|
|
node.closingElement = closingElement;
|
|
node.transformFlags |= propagateChildFlags(node.openingElement) | propagateChildrenFlags(node.children) | propagateChildFlags(node.closingElement) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxElement(node, openingElement, children, closingElement) {
|
|
return node.openingElement !== openingElement || node.children !== children || node.closingElement !== closingElement ? update(createJsxElement(openingElement, children, closingElement), node) : node;
|
|
}
|
|
function createJsxSelfClosingElement(tagName, typeArguments, attributes) {
|
|
const node = createBaseNode(282 /* JsxSelfClosingElement */);
|
|
node.tagName = tagName;
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.attributes = attributes;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.attributes) | 2 /* ContainsJsx */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateJsxSelfClosingElement(node, tagName, typeArguments, attributes) {
|
|
return node.tagName !== tagName || node.typeArguments !== typeArguments || node.attributes !== attributes ? update(createJsxSelfClosingElement(tagName, typeArguments, attributes), node) : node;
|
|
}
|
|
function createJsxOpeningElement(tagName, typeArguments, attributes) {
|
|
const node = createBaseNode(283 /* JsxOpeningElement */);
|
|
node.tagName = tagName;
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.attributes = attributes;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.attributes) | 2 /* ContainsJsx */;
|
|
if (typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateJsxOpeningElement(node, tagName, typeArguments, attributes) {
|
|
return node.tagName !== tagName || node.typeArguments !== typeArguments || node.attributes !== attributes ? update(createJsxOpeningElement(tagName, typeArguments, attributes), node) : node;
|
|
}
|
|
function createJsxClosingElement(tagName) {
|
|
const node = createBaseNode(284 /* JsxClosingElement */);
|
|
node.tagName = tagName;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxClosingElement(node, tagName) {
|
|
return node.tagName !== tagName ? update(createJsxClosingElement(tagName), node) : node;
|
|
}
|
|
function createJsxFragment(openingFragment, children, closingFragment) {
|
|
const node = createBaseNode(285 /* JsxFragment */);
|
|
node.openingFragment = openingFragment;
|
|
node.children = createNodeArray(children);
|
|
node.closingFragment = closingFragment;
|
|
node.transformFlags |= propagateChildFlags(node.openingFragment) | propagateChildrenFlags(node.children) | propagateChildFlags(node.closingFragment) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxFragment(node, openingFragment, children, closingFragment) {
|
|
return node.openingFragment !== openingFragment || node.children !== children || node.closingFragment !== closingFragment ? update(createJsxFragment(openingFragment, children, closingFragment), node) : node;
|
|
}
|
|
function createJsxText(text, containsOnlyTriviaWhiteSpaces) {
|
|
const node = createBaseNode(11 /* JsxText */);
|
|
node.text = text;
|
|
node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces;
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxText(node, text, containsOnlyTriviaWhiteSpaces) {
|
|
return node.text !== text || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces ? update(createJsxText(text, containsOnlyTriviaWhiteSpaces), node) : node;
|
|
}
|
|
function createJsxOpeningFragment() {
|
|
const node = createBaseNode(286 /* JsxOpeningFragment */);
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function createJsxJsxClosingFragment() {
|
|
const node = createBaseNode(287 /* JsxClosingFragment */);
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function createJsxAttribute(name, initializer) {
|
|
const node = createBaseNode(288 /* JsxAttribute */);
|
|
node.name = name;
|
|
node.initializer = initializer;
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxAttribute(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? update(createJsxAttribute(name, initializer), node) : node;
|
|
}
|
|
function createJsxAttributes(properties) {
|
|
const node = createBaseNode(289 /* JsxAttributes */);
|
|
node.properties = createNodeArray(properties);
|
|
node.transformFlags |= propagateChildrenFlags(node.properties) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxAttributes(node, properties) {
|
|
return node.properties !== properties ? update(createJsxAttributes(properties), node) : node;
|
|
}
|
|
function createJsxSpreadAttribute(expression) {
|
|
const node = createBaseNode(290 /* JsxSpreadAttribute */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxSpreadAttribute(node, expression) {
|
|
return node.expression !== expression ? update(createJsxSpreadAttribute(expression), node) : node;
|
|
}
|
|
function createJsxExpression(dotDotDotToken, expression) {
|
|
const node = createBaseNode(291 /* JsxExpression */);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | propagateChildFlags(node.expression) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxExpression(node, expression) {
|
|
return node.expression !== expression ? update(createJsxExpression(node.dotDotDotToken, expression), node) : node;
|
|
}
|
|
function createCaseClause(expression, statements) {
|
|
const node = createBaseNode(292 /* CaseClause */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.statements = createNodeArray(statements);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateCaseClause(node, expression, statements) {
|
|
return node.expression !== expression || node.statements !== statements ? update(createCaseClause(expression, statements), node) : node;
|
|
}
|
|
function createDefaultClause(statements) {
|
|
const node = createBaseNode(293 /* DefaultClause */);
|
|
node.statements = createNodeArray(statements);
|
|
node.transformFlags = propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateDefaultClause(node, statements) {
|
|
return node.statements !== statements ? update(createDefaultClause(statements), node) : node;
|
|
}
|
|
function createHeritageClause(token, types) {
|
|
const node = createBaseNode(294 /* HeritageClause */);
|
|
node.token = token;
|
|
node.types = createNodeArray(types);
|
|
node.transformFlags |= propagateChildrenFlags(node.types);
|
|
switch (token) {
|
|
case 94 /* ExtendsKeyword */:
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 117 /* ImplementsKeyword */:
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
break;
|
|
default:
|
|
return Debug.assertNever(token);
|
|
}
|
|
return node;
|
|
}
|
|
function updateHeritageClause(node, types) {
|
|
return node.types !== types ? update(createHeritageClause(node.token, types), node) : node;
|
|
}
|
|
function createCatchClause(variableDeclaration, block) {
|
|
const node = createBaseNode(295 /* CatchClause */);
|
|
if (typeof variableDeclaration === "string" || variableDeclaration && !isVariableDeclaration(variableDeclaration)) {
|
|
variableDeclaration = createVariableDeclaration(
|
|
variableDeclaration,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
node.variableDeclaration = variableDeclaration;
|
|
node.block = block;
|
|
node.transformFlags |= propagateChildFlags(node.variableDeclaration) | propagateChildFlags(node.block);
|
|
if (!variableDeclaration)
|
|
node.transformFlags |= 64 /* ContainsES2019 */;
|
|
return node;
|
|
}
|
|
function updateCatchClause(node, variableDeclaration, block) {
|
|
return node.variableDeclaration !== variableDeclaration || node.block !== block ? update(createCatchClause(variableDeclaration, block), node) : node;
|
|
}
|
|
function createPropertyAssignment(name, initializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
299 /* PropertyAssignment */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.initializer = parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer);
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
node.questionToken = void 0;
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
function updatePropertyAssignment(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? finishUpdatePropertyAssignment(createPropertyAssignment(name, initializer), node) : node;
|
|
}
|
|
function finishUpdatePropertyAssignment(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
updated.questionToken = original.questionToken;
|
|
updated.exclamationToken = original.exclamationToken;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createShorthandPropertyAssignment(name, objectAssignmentInitializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
300 /* ShorthandPropertyAssignment */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.objectAssignmentInitializer = objectAssignmentInitializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer);
|
|
node.transformFlags |= propagateChildFlags(node.objectAssignmentInitializer) | 1024 /* ContainsES2015 */;
|
|
node.equalsToken = void 0;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
node.questionToken = void 0;
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
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) {
|
|
updated.equalsToken = original.equalsToken;
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
updated.questionToken = original.questionToken;
|
|
updated.exclamationToken = original.exclamationToken;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createSpreadAssignment(expression) {
|
|
const node = createBaseNode(301 /* SpreadAssignment */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 128 /* ContainsES2018 */ | 65536 /* ContainsObjectRestOrSpread */;
|
|
return node;
|
|
}
|
|
function updateSpreadAssignment(node, expression) {
|
|
return node.expression !== expression ? update(createSpreadAssignment(expression), node) : node;
|
|
}
|
|
function createEnumMember(name, initializer) {
|
|
const node = createBaseNode(302 /* EnumMember */);
|
|
node.name = asName(name);
|
|
node.initializer = initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateEnumMember(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? update(createEnumMember(name, initializer), node) : node;
|
|
}
|
|
function createSourceFile2(statements, endOfFileToken, flags2) {
|
|
const node = baseFactory2.createBaseSourceFileNode(308 /* SourceFile */);
|
|
node.statements = createNodeArray(statements);
|
|
node.endOfFileToken = endOfFileToken;
|
|
node.flags |= flags2;
|
|
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) {
|
|
const node = source.redirectInfo ? Object.create(source.redirectInfo.redirectTarget) : baseFactory2.createBaseSourceFileNode(308 /* SourceFile */);
|
|
for (const p in source) {
|
|
if (p === "emitNode" || hasProperty(node, p) || !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;
|
|
}
|
|
function updateSourceFile(node, statements, isDeclarationFile = node.isDeclarationFile, referencedFiles = node.referencedFiles, typeReferenceDirectives = node.typeReferenceDirectives, hasNoDefaultLib = node.hasNoDefaultLib, 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;
|
|
}
|
|
function createBundle(sourceFiles, prepends = emptyArray) {
|
|
const node = createBaseNode(309 /* Bundle */);
|
|
node.prepends = prepends;
|
|
node.sourceFiles = sourceFiles;
|
|
return node;
|
|
}
|
|
function updateBundle(node, sourceFiles, prepends = emptyArray) {
|
|
return node.sourceFiles !== sourceFiles || node.prepends !== prepends ? update(createBundle(sourceFiles, prepends), node) : node;
|
|
}
|
|
function createUnparsedSource(prologues, syntheticReferences, texts) {
|
|
const node = createBaseNode(310 /* UnparsedSource */);
|
|
node.prologues = prologues;
|
|
node.syntheticReferences = syntheticReferences;
|
|
node.texts = texts;
|
|
node.fileName = "";
|
|
node.text = "";
|
|
node.referencedFiles = emptyArray;
|
|
node.libReferenceDirectives = emptyArray;
|
|
node.getLineAndCharacterOfPosition = (pos) => getLineAndCharacterOfPosition(node, pos);
|
|
return node;
|
|
}
|
|
function createBaseUnparsedNode(kind, data) {
|
|
const node = createBaseNode(kind);
|
|
node.data = data;
|
|
return node;
|
|
}
|
|
function createUnparsedPrologue(data) {
|
|
return createBaseUnparsedNode(303 /* UnparsedPrologue */, data);
|
|
}
|
|
function createUnparsedPrepend(data, texts) {
|
|
const node = createBaseUnparsedNode(304 /* UnparsedPrepend */, data);
|
|
node.texts = texts;
|
|
return node;
|
|
}
|
|
function createUnparsedTextLike(data, internal) {
|
|
return createBaseUnparsedNode(internal ? 306 /* UnparsedInternalText */ : 305 /* UnparsedText */, data);
|
|
}
|
|
function createUnparsedSyntheticReference(section) {
|
|
const node = createBaseNode(307 /* UnparsedSyntheticReference */);
|
|
node.data = section.data;
|
|
node.section = section;
|
|
return node;
|
|
}
|
|
function createInputFiles() {
|
|
const node = createBaseNode(311 /* InputFiles */);
|
|
node.javascriptText = "";
|
|
node.declarationText = "";
|
|
return node;
|
|
}
|
|
function createSyntheticExpression(type, isSpread = false, tupleNameSource) {
|
|
const node = createBaseNode(234 /* SyntheticExpression */);
|
|
node.type = type;
|
|
node.isSpread = isSpread;
|
|
node.tupleNameSource = tupleNameSource;
|
|
return node;
|
|
}
|
|
function createSyntaxList(children) {
|
|
const node = createBaseNode(351 /* SyntaxList */);
|
|
node._children = children;
|
|
return node;
|
|
}
|
|
function createNotEmittedStatement(original) {
|
|
const node = createBaseNode(352 /* NotEmittedStatement */);
|
|
node.original = original;
|
|
setTextRange(node, original);
|
|
return node;
|
|
}
|
|
function createPartiallyEmittedExpression(expression, original) {
|
|
const node = createBaseNode(353 /* PartiallyEmittedExpression */);
|
|
node.expression = expression;
|
|
node.original = original;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
setTextRange(node, original);
|
|
return node;
|
|
}
|
|
function updatePartiallyEmittedExpression(node, expression) {
|
|
return node.expression !== expression ? update(createPartiallyEmittedExpression(expression, node.original), node) : node;
|
|
}
|
|
function flattenCommaElements(node) {
|
|
if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
|
|
if (isCommaListExpression(node)) {
|
|
return node.elements;
|
|
}
|
|
if (isBinaryExpression(node) && isCommaToken(node.operatorToken)) {
|
|
return [node.left, node.right];
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function createCommaListExpression(elements) {
|
|
const node = createBaseNode(354 /* CommaListExpression */);
|
|
node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements));
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
return node;
|
|
}
|
|
function updateCommaListExpression(node, elements) {
|
|
return node.elements !== elements ? update(createCommaListExpression(elements), node) : node;
|
|
}
|
|
function createEndOfDeclarationMarker(original) {
|
|
const node = createBaseNode(356 /* EndOfDeclarationMarker */);
|
|
node.emitNode = {};
|
|
node.original = original;
|
|
return node;
|
|
}
|
|
function createMergeDeclarationMarker(original) {
|
|
const node = createBaseNode(355 /* MergeDeclarationMarker */);
|
|
node.emitNode = {};
|
|
node.original = original;
|
|
return node;
|
|
}
|
|
function createSyntheticReferenceExpression(expression, thisArg) {
|
|
const node = createBaseNode(357 /* SyntheticReferenceExpression */);
|
|
node.expression = expression;
|
|
node.thisArg = thisArg;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg);
|
|
return node;
|
|
}
|
|
function updateSyntheticReferenceExpression(node, expression, thisArg) {
|
|
return node.expression !== expression || node.thisArg !== thisArg ? update(createSyntheticReferenceExpression(expression, thisArg), node) : node;
|
|
}
|
|
function cloneNode(node) {
|
|
if (node === void 0) {
|
|
return node;
|
|
}
|
|
const clone2 = isSourceFile(node) ? baseFactory2.createBaseSourceFileNode(308 /* SourceFile */) : isIdentifier(node) ? baseFactory2.createBaseIdentifierNode(79 /* Identifier */) : isPrivateIdentifier(node) ? baseFactory2.createBasePrivateIdentifierNode(80 /* PrivateIdentifier */) : !isNodeKind(node.kind) ? baseFactory2.createBaseTokenNode(node.kind) : baseFactory2.createBaseNode(node.kind);
|
|
clone2.flags |= node.flags & ~8 /* Synthesized */;
|
|
clone2.transformFlags = node.transformFlags;
|
|
setOriginalNode(clone2, node);
|
|
for (const key in node) {
|
|
if (hasProperty(clone2, key) || !hasProperty(node, key)) {
|
|
continue;
|
|
}
|
|
clone2[key] = node[key];
|
|
}
|
|
return clone2;
|
|
}
|
|
function createImmediatelyInvokedFunctionExpression(statements, param, paramValue) {
|
|
return createCallExpression(
|
|
createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
param ? [param] : [],
|
|
void 0,
|
|
createBlock(statements, true)
|
|
),
|
|
void 0,
|
|
paramValue ? [paramValue] : []
|
|
);
|
|
}
|
|
function createImmediatelyInvokedArrowFunction(statements, param, paramValue) {
|
|
return createCallExpression(
|
|
createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
param ? [param] : [],
|
|
void 0,
|
|
void 0,
|
|
createBlock(statements, true)
|
|
),
|
|
void 0,
|
|
paramValue ? [paramValue] : []
|
|
);
|
|
}
|
|
function createVoidZero() {
|
|
return createVoidExpression(createNumericLiteral("0"));
|
|
}
|
|
function createExportDefault(expression) {
|
|
return createExportAssignment(
|
|
void 0,
|
|
false,
|
|
expression
|
|
);
|
|
}
|
|
function createExternalModuleExport(exportName) {
|
|
return createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
createNamedExports([
|
|
createExportSpecifier(false, void 0, exportName)
|
|
])
|
|
);
|
|
}
|
|
function createTypeCheck(value, tag) {
|
|
return tag === "undefined" ? factory2.createStrictEquality(value, createVoidZero()) : factory2.createStrictEquality(createTypeOfExpression(value), createStringLiteral(tag));
|
|
}
|
|
function createMethodCall(object, methodName, argumentsList) {
|
|
if (isCallChain(object)) {
|
|
return createCallChain(
|
|
createPropertyAccessChain(object, void 0, methodName),
|
|
void 0,
|
|
void 0,
|
|
argumentsList
|
|
);
|
|
}
|
|
return createCallExpression(
|
|
createPropertyAccessExpression(object, methodName),
|
|
void 0,
|
|
argumentsList
|
|
);
|
|
}
|
|
function createFunctionBindCall(target, thisArg, argumentsList) {
|
|
return createMethodCall(target, "bind", [thisArg, ...argumentsList]);
|
|
}
|
|
function createFunctionCallCall(target, thisArg, argumentsList) {
|
|
return createMethodCall(target, "call", [thisArg, ...argumentsList]);
|
|
}
|
|
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 === void 0 ? [] : [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) {
|
|
const properties = [];
|
|
tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable));
|
|
tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable));
|
|
let isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable));
|
|
isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData;
|
|
let isAccessor2 = tryAddPropertyAssignment(properties, "get", attributes.get);
|
|
isAccessor2 = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor2;
|
|
Debug.assert(!(isData && isAccessor2), "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 /* ParenthesizedExpression */:
|
|
return updateParenthesizedExpression(outerExpression, expression);
|
|
case 213 /* TypeAssertionExpression */:
|
|
return updateTypeAssertion(outerExpression, outerExpression.type, expression);
|
|
case 231 /* AsExpression */:
|
|
return updateAsExpression(outerExpression, expression, outerExpression.type);
|
|
case 235 /* SatisfiesExpression */:
|
|
return updateSatisfiesExpression(outerExpression, expression, outerExpression.type);
|
|
case 232 /* NonNullExpression */:
|
|
return updateNonNullExpression(outerExpression, expression);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return updatePartiallyEmittedExpression(outerExpression, expression);
|
|
}
|
|
}
|
|
function isIgnorableParen(node) {
|
|
return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
|
|
}
|
|
function restoreOuterExpressions(outerExpression, innerExpression, kinds = 15 /* All */) {
|
|
if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
|
|
return updateOuterExpression(
|
|
outerExpression,
|
|
restoreOuterExpressions(outerExpression.expression, innerExpression)
|
|
);
|
|
}
|
|
return innerExpression;
|
|
}
|
|
function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) {
|
|
if (!outermostLabeledStatement) {
|
|
return node;
|
|
}
|
|
const updated = updateLabeledStatement(
|
|
outermostLabeledStatement,
|
|
outermostLabeledStatement.label,
|
|
isLabeledStatement(outermostLabeledStatement.statement) ? restoreEnclosingLabel(node, outermostLabeledStatement.statement) : node
|
|
);
|
|
if (afterRestoreLabelCallback) {
|
|
afterRestoreLabelCallback(outermostLabeledStatement);
|
|
}
|
|
return updated;
|
|
}
|
|
function shouldBeCapturedInTempVariable(node, cacheIdentifiers) {
|
|
const target = skipParentheses(node);
|
|
switch (target.kind) {
|
|
case 79 /* Identifier */:
|
|
return cacheIdentifiers;
|
|
case 108 /* ThisKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return false;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
const elements = target.elements;
|
|
if (elements.length === 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return target.properties.length > 0;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
|
|
const callee = skipOuterExpressions(expression, 15 /* All */);
|
|
let thisArg;
|
|
let target;
|
|
if (isSuperProperty(callee)) {
|
|
thisArg = createThis();
|
|
target = callee;
|
|
} else if (isSuperKeyword(callee)) {
|
|
thisArg = createThis();
|
|
target = languageVersion !== void 0 && languageVersion < 2 /* ES2015 */ ? setTextRange(createIdentifier("_super"), callee) : callee;
|
|
} else if (getEmitFlags(callee) & 8192 /* HelperName */) {
|
|
thisArg = createVoidZero();
|
|
target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee, false);
|
|
} else if (isPropertyAccessExpression(callee)) {
|
|
if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
|
|
thisArg = createTempVariable(recordTempVariable);
|
|
target = createPropertyAccessExpression(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
thisArg,
|
|
callee.expression
|
|
),
|
|
callee.expression
|
|
),
|
|
callee.name
|
|
);
|
|
setTextRange(target, callee);
|
|
} else {
|
|
thisArg = callee.expression;
|
|
target = callee;
|
|
}
|
|
} else if (isElementAccessExpression(callee)) {
|
|
if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
|
|
thisArg = createTempVariable(recordTempVariable);
|
|
target = createElementAccessExpression(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
thisArg,
|
|
callee.expression
|
|
),
|
|
callee.expression
|
|
),
|
|
callee.argumentExpression
|
|
);
|
|
setTextRange(target, callee);
|
|
} else {
|
|
thisArg = callee.expression;
|
|
target = callee;
|
|
}
|
|
} else {
|
|
thisArg = createVoidZero();
|
|
target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
}
|
|
return { target, thisArg };
|
|
}
|
|
function createAssignmentTargetWrapper(paramName, expression) {
|
|
return createPropertyAccessExpression(
|
|
createParenthesizedExpression(
|
|
createObjectLiteralExpression([
|
|
createSetAccessorDeclaration(
|
|
void 0,
|
|
"value",
|
|
[createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
paramName,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)],
|
|
createBlock([
|
|
createExpressionStatement(expression)
|
|
])
|
|
)
|
|
])
|
|
),
|
|
"value"
|
|
);
|
|
}
|
|
function inlineExpressions(expressions) {
|
|
return expressions.length > 10 ? createCommaListExpression(expressions) : reduceLeft(expressions, factory2.createComma);
|
|
}
|
|
function getName(node, allowComments, allowSourceMaps, emitFlags = 0) {
|
|
const nodeName = getNameOfDeclaration(node);
|
|
if (nodeName && isIdentifier(nodeName) && !isGeneratedIdentifier(nodeName)) {
|
|
const name = setParent(setTextRange(cloneNode(nodeName), nodeName), nodeName.parent);
|
|
emitFlags |= getEmitFlags(nodeName);
|
|
if (!allowSourceMaps)
|
|
emitFlags |= 96 /* NoSourceMap */;
|
|
if (!allowComments)
|
|
emitFlags |= 3072 /* NoComments */;
|
|
if (emitFlags)
|
|
setEmitFlags(name, emitFlags);
|
|
return name;
|
|
}
|
|
return getGeneratedNameForNode(node);
|
|
}
|
|
function getInternalName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 32768 /* LocalName */ | 65536 /* InternalName */);
|
|
}
|
|
function getLocalName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 32768 /* LocalName */);
|
|
}
|
|
function getExportName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 16384 /* ExportName */);
|
|
}
|
|
function getDeclarationName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps);
|
|
}
|
|
function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) {
|
|
const qualifiedName = createPropertyAccessExpression(ns, nodeIsSynthesized(name) ? name : cloneNode(name));
|
|
setTextRange(qualifiedName, name);
|
|
let emitFlags = 0;
|
|
if (!allowSourceMaps)
|
|
emitFlags |= 96 /* NoSourceMap */;
|
|
if (!allowComments)
|
|
emitFlags |= 3072 /* NoComments */;
|
|
if (emitFlags)
|
|
setEmitFlags(qualifiedName, emitFlags);
|
|
return qualifiedName;
|
|
}
|
|
function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
|
|
if (ns && hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
|
|
}
|
|
return getExportName(node, allowComments, allowSourceMaps);
|
|
}
|
|
function copyPrologue(source, target, ensureUseStrict2, visitor) {
|
|
const offset = copyStandardPrologue(source, target, 0, ensureUseStrict2);
|
|
return copyCustomPrologue(source, target, offset, visitor);
|
|
}
|
|
function isUseStrictPrologue2(node) {
|
|
return isStringLiteral(node.expression) && node.expression.text === "use strict";
|
|
}
|
|
function createUseStrictPrologue() {
|
|
return startOnNewLine(createExpressionStatement(createStringLiteral("use strict")));
|
|
}
|
|
function copyStandardPrologue(source, target, statementOffset = 0, ensureUseStrict2) {
|
|
Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
|
|
let foundUseStrict = false;
|
|
const numStatements = source.length;
|
|
while (statementOffset < numStatements) {
|
|
const statement = source[statementOffset];
|
|
if (isPrologueDirective(statement)) {
|
|
if (isUseStrictPrologue2(statement)) {
|
|
foundUseStrict = true;
|
|
}
|
|
target.push(statement);
|
|
} else {
|
|
break;
|
|
}
|
|
statementOffset++;
|
|
}
|
|
if (ensureUseStrict2 && !foundUseStrict) {
|
|
target.push(createUseStrictPrologue());
|
|
}
|
|
return statementOffset;
|
|
}
|
|
function copyCustomPrologue(source, target, statementOffset, visitor, filter2 = returnTrue) {
|
|
const numStatements = source.length;
|
|
while (statementOffset !== void 0 && statementOffset < numStatements) {
|
|
const statement = source[statementOffset];
|
|
if (getEmitFlags(statement) & 2097152 /* CustomPrologue */ && filter2(statement)) {
|
|
append(target, visitor ? visitNode(statement, visitor, isStatement) : statement);
|
|
} else {
|
|
break;
|
|
}
|
|
statementOffset++;
|
|
}
|
|
return statementOffset;
|
|
}
|
|
function ensureUseStrict(statements) {
|
|
const foundUseStrict = findUseStrictPrologue(statements);
|
|
if (!foundUseStrict) {
|
|
return setTextRange(createNodeArray([createUseStrictPrologue(), ...statements]), statements);
|
|
}
|
|
return statements;
|
|
}
|
|
function liftToBlock(nodes) {
|
|
Debug.assert(every(nodes, isStatementOrBlock), "Cannot lift nodes to a Block.");
|
|
return singleOrUndefined(nodes) || createBlock(nodes);
|
|
}
|
|
function findSpanEnd(array, test, start) {
|
|
let i = start;
|
|
while (i < array.length && test(array[i])) {
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
function mergeLexicalEnvironment(statements, declarations) {
|
|
if (!some(declarations)) {
|
|
return statements;
|
|
}
|
|
const leftStandardPrologueEnd = findSpanEnd(statements, isPrologueDirective, 0);
|
|
const leftHoistedFunctionsEnd = findSpanEnd(statements, isHoistedFunction, leftStandardPrologueEnd);
|
|
const leftHoistedVariablesEnd = findSpanEnd(statements, isHoistedVariableStatement, leftHoistedFunctionsEnd);
|
|
const rightStandardPrologueEnd = findSpanEnd(declarations, isPrologueDirective, 0);
|
|
const rightHoistedFunctionsEnd = findSpanEnd(declarations, isHoistedFunction, rightStandardPrologueEnd);
|
|
const rightHoistedVariablesEnd = findSpanEnd(declarations, isHoistedVariableStatement, rightHoistedFunctionsEnd);
|
|
const rightCustomPrologueEnd = findSpanEnd(declarations, isCustomPrologue, rightHoistedVariablesEnd);
|
|
Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues");
|
|
const left = isNodeArray(statements) ? statements.slice() : statements;
|
|
if (rightCustomPrologueEnd > rightHoistedVariablesEnd) {
|
|
left.splice(leftHoistedVariablesEnd, 0, ...declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd));
|
|
}
|
|
if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) {
|
|
left.splice(leftHoistedFunctionsEnd, 0, ...declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd));
|
|
}
|
|
if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) {
|
|
left.splice(leftStandardPrologueEnd, 0, ...declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd));
|
|
}
|
|
if (rightStandardPrologueEnd > 0) {
|
|
if (leftStandardPrologueEnd === 0) {
|
|
left.splice(0, 0, ...declarations.slice(0, rightStandardPrologueEnd));
|
|
} else {
|
|
const leftPrologues = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < leftStandardPrologueEnd; i++) {
|
|
const leftPrologue = statements[i];
|
|
leftPrologues.set(leftPrologue.expression.text, true);
|
|
}
|
|
for (let i = rightStandardPrologueEnd - 1; i >= 0; i--) {
|
|
const rightPrologue = declarations[i];
|
|
if (!leftPrologues.has(rightPrologue.expression.text)) {
|
|
left.unshift(rightPrologue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isNodeArray(statements)) {
|
|
return setTextRange(createNodeArray(left, statements.hasTrailingComma), statements);
|
|
}
|
|
return statements;
|
|
}
|
|
function updateModifiers(node, modifiers) {
|
|
var _a2;
|
|
let modifierArray;
|
|
if (typeof modifiers === "number") {
|
|
modifierArray = createModifiersFromModifierFlags(modifiers);
|
|
} else {
|
|
modifierArray = modifiers;
|
|
}
|
|
return isTypeParameterDeclaration(node) ? updateTypeParameterDeclaration(node, modifierArray, node.name, node.constraint, node.default) : isParameter(node) ? updateParameterDeclaration(node, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) : isConstructorTypeNode(node) ? updateConstructorTypeNode1(node, modifierArray, node.typeParameters, node.parameters, node.type) : isPropertySignature(node) ? updatePropertySignature(node, modifierArray, node.name, node.questionToken, node.type) : isPropertyDeclaration(node) ? updatePropertyDeclaration(node, modifierArray, node.name, (_a2 = node.questionToken) != null ? _a2 : node.exclamationToken, node.type, node.initializer) : isMethodSignature(node) ? updateMethodSignature(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) : isMethodDeclaration(node) ? updateMethodDeclaration(node, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) : isConstructorDeclaration(node) ? updateConstructorDeclaration(node, modifierArray, node.parameters, node.body) : isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.type, node.body) : isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.body) : isIndexSignatureDeclaration(node) ? updateIndexSignature(node, modifierArray, node.parameters, node.type) : isFunctionExpression(node) ? updateFunctionExpression(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isArrowFunction(node) ? updateArrowFunction(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) : isClassExpression(node) ? updateClassExpression(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isVariableStatement(node) ? updateVariableStatement(node, modifierArray, node.declarationList) : isFunctionDeclaration(node) ? updateFunctionDeclaration(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isClassDeclaration(node) ? updateClassDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, modifierArray, node.name, node.typeParameters, node.type) : isEnumDeclaration(node) ? updateEnumDeclaration(node, modifierArray, node.name, node.members) : isModuleDeclaration(node) ? updateModuleDeclaration(node, modifierArray, node.name, node.body) : isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, modifierArray, node.isTypeOnly, node.name, node.moduleReference) : isImportDeclaration(node) ? updateImportDeclaration(node, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause) : isExportAssignment(node) ? updateExportAssignment(node, modifierArray, node.expression) : isExportDeclaration(node) ? updateExportDeclaration(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) : Debug.assertNever(node);
|
|
}
|
|
function asNodeArray(array) {
|
|
return array ? createNodeArray(array) : void 0;
|
|
}
|
|
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 && isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement;
|
|
}
|
|
}
|
|
function updateWithoutOriginal(updated, original) {
|
|
if (updated !== original) {
|
|
setTextRange(updated, original);
|
|
}
|
|
return updated;
|
|
}
|
|
function updateWithOriginal(updated, original) {
|
|
if (updated !== original) {
|
|
setOriginalNode(updated, original);
|
|
setTextRange(updated, original);
|
|
}
|
|
return updated;
|
|
}
|
|
function getDefaultTagNameForKind(kind) {
|
|
switch (kind) {
|
|
case 346 /* JSDocTypeTag */:
|
|
return "type";
|
|
case 344 /* JSDocReturnTag */:
|
|
return "returns";
|
|
case 345 /* JSDocThisTag */:
|
|
return "this";
|
|
case 342 /* JSDocEnumTag */:
|
|
return "enum";
|
|
case 333 /* JSDocAuthorTag */:
|
|
return "author";
|
|
case 335 /* JSDocClassTag */:
|
|
return "class";
|
|
case 336 /* JSDocPublicTag */:
|
|
return "public";
|
|
case 337 /* JSDocPrivateTag */:
|
|
return "private";
|
|
case 338 /* JSDocProtectedTag */:
|
|
return "protected";
|
|
case 339 /* JSDocReadonlyTag */:
|
|
return "readonly";
|
|
case 340 /* JSDocOverrideTag */:
|
|
return "override";
|
|
case 347 /* JSDocTemplateTag */:
|
|
return "template";
|
|
case 348 /* JSDocTypedefTag */:
|
|
return "typedef";
|
|
case 343 /* JSDocParameterTag */:
|
|
return "param";
|
|
case 350 /* JSDocPropertyTag */:
|
|
return "prop";
|
|
case 341 /* JSDocCallbackTag */:
|
|
return "callback";
|
|
case 331 /* JSDocAugmentsTag */:
|
|
return "augments";
|
|
case 332 /* JSDocImplementsTag */:
|
|
return "implements";
|
|
default:
|
|
return Debug.fail(`Unsupported kind: ${Debug.formatSyntaxKind(kind)}`);
|
|
}
|
|
}
|
|
var rawTextScanner;
|
|
var invalidValueSentinel = {};
|
|
function getCookedText(kind, rawText) {
|
|
if (!rawTextScanner) {
|
|
rawTextScanner = createScanner(99 /* Latest */, false, 0 /* Standard */);
|
|
}
|
|
switch (kind) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
rawTextScanner.setText("`" + rawText + "`");
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
rawTextScanner.setText("`" + rawText + "${");
|
|
break;
|
|
case 16 /* TemplateMiddle */:
|
|
rawTextScanner.setText("}" + rawText + "${");
|
|
break;
|
|
case 17 /* TemplateTail */:
|
|
rawTextScanner.setText("}" + rawText + "`");
|
|
break;
|
|
}
|
|
let token = rawTextScanner.scan();
|
|
if (token === 19 /* CloseBraceToken */) {
|
|
token = rawTextScanner.reScanTemplateToken(false);
|
|
}
|
|
if (rawTextScanner.isUnterminated()) {
|
|
rawTextScanner.setText(void 0);
|
|
return invalidValueSentinel;
|
|
}
|
|
let tokenValue;
|
|
switch (token) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
tokenValue = rawTextScanner.getTokenValue();
|
|
break;
|
|
}
|
|
if (tokenValue === void 0 || rawTextScanner.scan() !== 1 /* EndOfFileToken */) {
|
|
rawTextScanner.setText(void 0);
|
|
return invalidValueSentinel;
|
|
}
|
|
rawTextScanner.setText(void 0);
|
|
return tokenValue;
|
|
}
|
|
function propagateIdentifierNameFlags(node) {
|
|
return propagateChildFlags(node) & ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
}
|
|
function propagatePropertyNameFlagsOfChild(node, transformFlags) {
|
|
return transformFlags | node.transformFlags & 134234112 /* PropertyNamePropagatingFlags */;
|
|
}
|
|
function propagateChildFlags(child) {
|
|
if (!child)
|
|
return 0 /* None */;
|
|
const childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind);
|
|
return isNamedDeclaration(child) && isPropertyName(child.name) ? propagatePropertyNameFlagsOfChild(child.name, childFlags) : childFlags;
|
|
}
|
|
function propagateChildrenFlags(children) {
|
|
return children ? children.transformFlags : 0 /* None */;
|
|
}
|
|
function aggregateChildrenFlags(children) {
|
|
let subtreeFlags = 0 /* None */;
|
|
for (const child of children) {
|
|
subtreeFlags |= propagateChildFlags(child);
|
|
}
|
|
children.transformFlags = subtreeFlags;
|
|
}
|
|
function getTransformFlagsSubtreeExclusions(kind) {
|
|
if (kind >= 179 /* FirstTypeNode */ && kind <= 202 /* LastTypeNode */) {
|
|
return -2 /* TypeExcludes */;
|
|
}
|
|
switch (kind) {
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return -2147450880 /* ArrayLiteralOrCallOrNewExcludes */;
|
|
case 264 /* ModuleDeclaration */:
|
|
return -1941676032 /* ModuleExcludes */;
|
|
case 166 /* Parameter */:
|
|
return -2147483648 /* ParameterExcludes */;
|
|
case 216 /* ArrowFunction */:
|
|
return -2072174592 /* ArrowFunctionExcludes */;
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return -1937940480 /* FunctionExcludes */;
|
|
case 258 /* VariableDeclarationList */:
|
|
return -2146893824 /* VariableDeclarationListExcludes */;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return -2147344384 /* ClassExcludes */;
|
|
case 173 /* Constructor */:
|
|
return -1937948672 /* ConstructorExcludes */;
|
|
case 169 /* PropertyDeclaration */:
|
|
return -2013249536 /* PropertyExcludes */;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return -2005057536 /* MethodOrAccessorExcludes */;
|
|
case 131 /* AnyKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 165 /* TypeParameter */:
|
|
case 168 /* PropertySignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return -2 /* TypeExcludes */;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return -2147278848 /* ObjectLiteralExcludes */;
|
|
case 295 /* CatchClause */:
|
|
return -2147418112 /* CatchClauseExcludes */;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
return -2147450880 /* BindingPatternExcludes */;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 106 /* SuperKeyword */:
|
|
return -2147483648 /* OuterExpressionExcludes */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return -2147483648 /* PropertyAccessExcludes */;
|
|
default:
|
|
return -2147483648 /* NodeExcludes */;
|
|
}
|
|
}
|
|
var baseFactory = createBaseNodeFactory();
|
|
function makeSynthetic(node) {
|
|
node.flags |= 8 /* Synthesized */;
|
|
return node;
|
|
}
|
|
var syntheticFactory = {
|
|
createBaseSourceFileNode: (kind) => makeSynthetic(baseFactory.createBaseSourceFileNode(kind)),
|
|
createBaseIdentifierNode: (kind) => makeSynthetic(baseFactory.createBaseIdentifierNode(kind)),
|
|
createBasePrivateIdentifierNode: (kind) => makeSynthetic(baseFactory.createBasePrivateIdentifierNode(kind)),
|
|
createBaseTokenNode: (kind) => makeSynthetic(baseFactory.createBaseTokenNode(kind)),
|
|
createBaseNode: (kind) => makeSynthetic(baseFactory.createBaseNode(kind))
|
|
};
|
|
var factory = createNodeFactory(4 /* NoIndentationOnFreshPropertyAccess */, syntheticFactory);
|
|
function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) {
|
|
let stripInternal;
|
|
let bundleFileInfo;
|
|
let fileName;
|
|
let text;
|
|
let length2;
|
|
let sourceMapPath;
|
|
let sourceMapText;
|
|
let getText;
|
|
let getSourceMapText;
|
|
let oldFileOfCurrentEmit;
|
|
if (!isString(textOrInputFiles)) {
|
|
Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts");
|
|
fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || "";
|
|
sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath;
|
|
getText = () => mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText;
|
|
getSourceMapText = () => mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText;
|
|
length2 = () => getText().length;
|
|
if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) {
|
|
Debug.assert(mapTextOrStripInternal === void 0 || typeof mapTextOrStripInternal === "boolean");
|
|
stripInternal = mapTextOrStripInternal;
|
|
bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts;
|
|
oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit;
|
|
}
|
|
} else {
|
|
fileName = "";
|
|
text = textOrInputFiles;
|
|
length2 = textOrInputFiles.length;
|
|
sourceMapPath = mapPathOrType;
|
|
sourceMapText = mapTextOrStripInternal;
|
|
}
|
|
const node = oldFileOfCurrentEmit ? parseOldFileOfCurrentEmit(Debug.checkDefined(bundleFileInfo)) : parseUnparsedSourceFile(bundleFileInfo, stripInternal, length2);
|
|
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 {
|
|
Debug.assert(!oldFileOfCurrentEmit);
|
|
node.text = text != null ? text : "";
|
|
node.sourceMapText = sourceMapText;
|
|
}
|
|
return node;
|
|
}
|
|
function parseUnparsedSourceFile(bundleFileInfo, stripInternal, length2) {
|
|
let prologues;
|
|
let helpers;
|
|
let referencedFiles;
|
|
let typeReferenceDirectives;
|
|
let libReferenceDirectives;
|
|
let prependChildren;
|
|
let texts;
|
|
let hasNoDefaultLib;
|
|
for (const section of bundleFileInfo ? bundleFileInfo.sections : emptyArray) {
|
|
switch (section.kind) {
|
|
case "prologue" /* Prologue */:
|
|
prologues = append(prologues, setTextRange(factory.createUnparsedPrologue(section.data), section));
|
|
break;
|
|
case "emitHelpers" /* EmitHelpers */:
|
|
helpers = append(helpers, getAllUnscopedEmitHelpers().get(section.data));
|
|
break;
|
|
case "no-default-lib" /* NoDefaultLib */:
|
|
hasNoDefaultLib = true;
|
|
break;
|
|
case "reference" /* Reference */:
|
|
referencedFiles = append(referencedFiles, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "type" /* Type */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "type-import" /* TypeResolutionModeImport */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: 99 /* ESNext */ });
|
|
break;
|
|
case "type-require" /* TypeResolutionModeRequire */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: 1 /* CommonJS */ });
|
|
break;
|
|
case "lib" /* Lib */:
|
|
libReferenceDirectives = append(libReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "prepend" /* Prepend */:
|
|
let prependTexts;
|
|
for (const text of section.texts) {
|
|
if (!stripInternal || text.kind !== "internal" /* Internal */) {
|
|
prependTexts = append(prependTexts, setTextRange(factory.createUnparsedTextLike(text.data, text.kind === "internal" /* Internal */), text));
|
|
}
|
|
}
|
|
prependChildren = addRange(prependChildren, prependTexts);
|
|
texts = append(texts, factory.createUnparsedPrepend(section.data, prependTexts != null ? prependTexts : emptyArray));
|
|
break;
|
|
case "internal" /* Internal */:
|
|
if (stripInternal) {
|
|
if (!texts)
|
|
texts = [];
|
|
break;
|
|
}
|
|
case "text" /* Text */:
|
|
texts = append(texts, setTextRange(factory.createUnparsedTextLike(section.data, section.kind === "internal" /* Internal */), section));
|
|
break;
|
|
default:
|
|
Debug.assertNever(section);
|
|
}
|
|
}
|
|
if (!texts) {
|
|
const textNode = factory.createUnparsedTextLike(void 0, false);
|
|
setTextRangePosWidth(textNode, 0, typeof length2 === "function" ? length2() : length2);
|
|
texts = [textNode];
|
|
}
|
|
const node = parseNodeFactory.createUnparsedSource(prologues != null ? prologues : emptyArray, void 0, texts);
|
|
setEachParent(prologues, node);
|
|
setEachParent(texts, node);
|
|
setEachParent(prependChildren, node);
|
|
node.hasNoDefaultLib = hasNoDefaultLib;
|
|
node.helpers = helpers;
|
|
node.referencedFiles = referencedFiles || emptyArray;
|
|
node.typeReferenceDirectives = typeReferenceDirectives;
|
|
node.libReferenceDirectives = libReferenceDirectives || emptyArray;
|
|
return node;
|
|
}
|
|
function parseOldFileOfCurrentEmit(bundleFileInfo) {
|
|
let texts;
|
|
let syntheticReferences;
|
|
for (const section of bundleFileInfo.sections) {
|
|
switch (section.kind) {
|
|
case "internal" /* Internal */:
|
|
case "text" /* Text */:
|
|
texts = append(texts, setTextRange(factory.createUnparsedTextLike(section.data, section.kind === "internal" /* Internal */), section));
|
|
break;
|
|
case "no-default-lib" /* NoDefaultLib */:
|
|
case "reference" /* Reference */:
|
|
case "type" /* Type */:
|
|
case "type-import" /* TypeResolutionModeImport */:
|
|
case "type-require" /* TypeResolutionModeRequire */:
|
|
case "lib" /* Lib */:
|
|
syntheticReferences = append(syntheticReferences, setTextRange(factory.createUnparsedSyntheticReference(section), section));
|
|
break;
|
|
case "prologue" /* Prologue */:
|
|
case "emitHelpers" /* EmitHelpers */:
|
|
case "prepend" /* Prepend */:
|
|
break;
|
|
default:
|
|
Debug.assertNever(section);
|
|
}
|
|
}
|
|
const node = factory.createUnparsedSource(emptyArray, syntheticReferences, texts != null ? texts : emptyArray);
|
|
setEachParent(syntheticReferences, node);
|
|
setEachParent(texts, node);
|
|
node.helpers = map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, (name) => getAllUnscopedEmitHelpers().get(name));
|
|
return node;
|
|
}
|
|
function createInputFilesWithFilePaths(readFileText, javascriptPath, javascriptMapPath, declarationPath, declarationMapPath, buildInfoPath, host, options) {
|
|
const node = parseNodeFactory.createInputFiles();
|
|
node.javascriptPath = javascriptPath;
|
|
node.javascriptMapPath = javascriptMapPath;
|
|
node.declarationPath = declarationPath;
|
|
node.declarationMapPath = declarationMapPath;
|
|
node.buildInfoPath = buildInfoPath;
|
|
const cache = /* @__PURE__ */ new Map();
|
|
const textGetter = (path) => {
|
|
if (path === void 0)
|
|
return void 0;
|
|
let value = cache.get(path);
|
|
if (value === void 0) {
|
|
value = readFileText(path);
|
|
cache.set(path, value !== void 0 ? value : false);
|
|
}
|
|
return value !== false ? value : void 0;
|
|
};
|
|
const definedTextGetter = (path) => {
|
|
const result = textGetter(path);
|
|
return result !== void 0 ? result : `/* Input file ${path} was missing */\r
|
|
`;
|
|
};
|
|
let buildInfo;
|
|
const getAndCacheBuildInfo = () => {
|
|
var _a2, _b;
|
|
if (buildInfo === void 0 && buildInfoPath) {
|
|
if (host == null ? void 0 : host.getBuildInfo) {
|
|
buildInfo = (_a2 = host.getBuildInfo(buildInfoPath, options.configFilePath)) != null ? _a2 : false;
|
|
} else {
|
|
const result = textGetter(buildInfoPath);
|
|
buildInfo = result !== void 0 ? (_b = getBuildInfo(buildInfoPath, result)) != null ? _b : false : false;
|
|
}
|
|
}
|
|
return buildInfo || void 0;
|
|
};
|
|
Object.defineProperties(node, {
|
|
javascriptText: { get: () => definedTextGetter(javascriptPath) },
|
|
javascriptMapText: { get: () => textGetter(javascriptMapPath) },
|
|
declarationText: { get: () => definedTextGetter(Debug.checkDefined(declarationPath)) },
|
|
declarationMapText: { get: () => textGetter(declarationMapPath) },
|
|
buildInfo: { get: getAndCacheBuildInfo }
|
|
});
|
|
return node;
|
|
}
|
|
function createInputFilesWithFileTexts(javascriptPath, javascriptText, javascriptMapPath, javascriptMapText, declarationPath, declarationText, declarationMapPath, declarationMapText, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
|
|
const node = parseNodeFactory.createInputFiles();
|
|
node.javascriptPath = javascriptPath;
|
|
node.javascriptText = javascriptText;
|
|
node.javascriptMapPath = javascriptMapPath;
|
|
node.javascriptMapText = javascriptMapText;
|
|
node.declarationPath = declarationPath;
|
|
node.declarationText = declarationText;
|
|
node.declarationMapPath = declarationMapPath;
|
|
node.declarationMapText = declarationMapText;
|
|
node.buildInfoPath = buildInfoPath;
|
|
node.buildInfo = buildInfo;
|
|
node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
|
|
return node;
|
|
}
|
|
function setOriginalNode(node, original) {
|
|
node.original = original;
|
|
if (original) {
|
|
const emitNode = original.emitNode;
|
|
if (emitNode)
|
|
node.emitNode = mergeEmitNode(emitNode, node.emitNode);
|
|
}
|
|
return node;
|
|
}
|
|
function mergeEmitNode(sourceEmitNode, destEmitNode) {
|
|
const {
|
|
flags,
|
|
leadingComments,
|
|
trailingComments,
|
|
commentRange,
|
|
sourceMapRange,
|
|
tokenSourceMapRanges,
|
|
constantValue,
|
|
helpers,
|
|
startsOnNewLine,
|
|
snippetElement
|
|
} = sourceEmitNode;
|
|
if (!destEmitNode)
|
|
destEmitNode = {};
|
|
if (leadingComments)
|
|
destEmitNode.leadingComments = addRange(leadingComments.slice(), destEmitNode.leadingComments);
|
|
if (trailingComments)
|
|
destEmitNode.trailingComments = addRange(trailingComments.slice(), destEmitNode.trailingComments);
|
|
if (flags)
|
|
destEmitNode.flags = flags & ~536870912 /* Immutable */;
|
|
if (commentRange)
|
|
destEmitNode.commentRange = commentRange;
|
|
if (sourceMapRange)
|
|
destEmitNode.sourceMapRange = sourceMapRange;
|
|
if (tokenSourceMapRanges)
|
|
destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges);
|
|
if (constantValue !== void 0)
|
|
destEmitNode.constantValue = constantValue;
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
destEmitNode.helpers = appendIfUnique(destEmitNode.helpers, helper);
|
|
}
|
|
}
|
|
if (startsOnNewLine !== void 0)
|
|
destEmitNode.startsOnNewLine = startsOnNewLine;
|
|
if (snippetElement !== void 0)
|
|
destEmitNode.snippetElement = snippetElement;
|
|
return destEmitNode;
|
|
}
|
|
function mergeTokenSourceMapRanges(sourceRanges, destRanges) {
|
|
if (!destRanges)
|
|
destRanges = [];
|
|
for (const key in sourceRanges) {
|
|
destRanges[key] = sourceRanges[key];
|
|
}
|
|
return destRanges;
|
|
}
|
|
|
|
// src/compiler/factory/emitNode.ts
|
|
function getOrCreateEmitNode(node) {
|
|
var _a2;
|
|
if (!node.emitNode) {
|
|
if (isParseTreeNode(node)) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return node.emitNode = { annotatedNodes: [node] };
|
|
}
|
|
const sourceFile = (_a2 = getSourceFileOfNode(getParseTreeNode(getSourceFileOfNode(node)))) != null ? _a2 : Debug.fail("Could not determine parsed source file.");
|
|
getOrCreateEmitNode(sourceFile).annotatedNodes.push(node);
|
|
}
|
|
node.emitNode = {};
|
|
} else {
|
|
Debug.assert(!(node.emitNode.flags & 536870912 /* Immutable */), "Invalid attempt to mutate an immutable node.");
|
|
}
|
|
return node.emitNode;
|
|
}
|
|
function disposeEmitNodes(sourceFile) {
|
|
var _a2, _b;
|
|
const annotatedNodes = (_b = (_a2 = getSourceFileOfNode(getParseTreeNode(sourceFile))) == null ? void 0 : _a2.emitNode) == null ? void 0 : _b.annotatedNodes;
|
|
if (annotatedNodes) {
|
|
for (const node of annotatedNodes) {
|
|
node.emitNode = void 0;
|
|
}
|
|
}
|
|
}
|
|
function removeAllComments(node) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.flags |= 3072 /* NoComments */;
|
|
emitNode.leadingComments = void 0;
|
|
emitNode.trailingComments = void 0;
|
|
return node;
|
|
}
|
|
function setEmitFlags(node, emitFlags) {
|
|
getOrCreateEmitNode(node).flags = emitFlags;
|
|
return node;
|
|
}
|
|
function addEmitFlags(node, emitFlags) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.flags = emitNode.flags | emitFlags;
|
|
return node;
|
|
}
|
|
function getSourceMapRange(node) {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.sourceMapRange) != null ? _b : node;
|
|
}
|
|
function setSourceMapRange(node, range) {
|
|
getOrCreateEmitNode(node).sourceMapRange = range;
|
|
return node;
|
|
}
|
|
function setTokenSourceMapRange(node, token, range) {
|
|
var _a2;
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
const tokenSourceMapRanges = (_a2 = emitNode.tokenSourceMapRanges) != null ? _a2 : emitNode.tokenSourceMapRanges = [];
|
|
tokenSourceMapRanges[token] = range;
|
|
return node;
|
|
}
|
|
function getStartsOnNewLine(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.startsOnNewLine;
|
|
}
|
|
function setStartsOnNewLine(node, newLine) {
|
|
getOrCreateEmitNode(node).startsOnNewLine = newLine;
|
|
return node;
|
|
}
|
|
function getCommentRange(node) {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.commentRange) != null ? _b : node;
|
|
}
|
|
function setCommentRange(node, range) {
|
|
getOrCreateEmitNode(node).commentRange = range;
|
|
return node;
|
|
}
|
|
function getSyntheticLeadingComments(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.leadingComments;
|
|
}
|
|
function setSyntheticLeadingComments(node, comments) {
|
|
getOrCreateEmitNode(node).leadingComments = comments;
|
|
return node;
|
|
}
|
|
function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
|
|
return setSyntheticLeadingComments(node, append(getSyntheticLeadingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
|
|
}
|
|
function getSyntheticTrailingComments(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.trailingComments;
|
|
}
|
|
function setSyntheticTrailingComments(node, comments) {
|
|
getOrCreateEmitNode(node).trailingComments = comments;
|
|
return node;
|
|
}
|
|
function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
|
|
return setSyntheticTrailingComments(node, append(getSyntheticTrailingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
|
|
}
|
|
function moveSyntheticComments(node, original) {
|
|
setSyntheticLeadingComments(node, getSyntheticLeadingComments(original));
|
|
setSyntheticTrailingComments(node, getSyntheticTrailingComments(original));
|
|
const emit = getOrCreateEmitNode(original);
|
|
emit.leadingComments = void 0;
|
|
emit.trailingComments = void 0;
|
|
return node;
|
|
}
|
|
function getConstantValue(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.constantValue;
|
|
}
|
|
function setConstantValue(node, value) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.constantValue = value;
|
|
return node;
|
|
}
|
|
function addEmitHelper(node, helper) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.helpers = append(emitNode.helpers, helper);
|
|
return node;
|
|
}
|
|
function addEmitHelpers(node, helpers) {
|
|
if (some(helpers)) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
for (const helper of helpers) {
|
|
emitNode.helpers = appendIfUnique(emitNode.helpers, helper);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getEmitHelpers(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.helpers;
|
|
}
|
|
function moveEmitHelpers(source, target, predicate) {
|
|
const sourceEmitNode = source.emitNode;
|
|
const sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers;
|
|
if (!some(sourceEmitHelpers))
|
|
return;
|
|
const targetEmitNode = getOrCreateEmitNode(target);
|
|
let helpersRemoved = 0;
|
|
for (let i = 0; i < sourceEmitHelpers.length; i++) {
|
|
const helper = sourceEmitHelpers[i];
|
|
if (predicate(helper)) {
|
|
helpersRemoved++;
|
|
targetEmitNode.helpers = appendIfUnique(targetEmitNode.helpers, helper);
|
|
} else if (helpersRemoved > 0) {
|
|
sourceEmitHelpers[i - helpersRemoved] = helper;
|
|
}
|
|
}
|
|
if (helpersRemoved > 0) {
|
|
sourceEmitHelpers.length -= helpersRemoved;
|
|
}
|
|
}
|
|
function getSnippetElement(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.snippetElement;
|
|
}
|
|
function setTypeNode(node, type) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.typeNode = type;
|
|
return node;
|
|
}
|
|
function getTypeNode(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.typeNode;
|
|
}
|
|
|
|
// src/compiler/factory/emitHelpers.ts
|
|
function createEmitHelperFactory(context) {
|
|
const factory2 = context.factory;
|
|
const immutableTrue = memoize(() => setEmitFlags(factory2.createTrue(), 536870912 /* Immutable */));
|
|
const immutableFalse = memoize(() => setEmitFlags(factory2.createFalse(), 536870912 /* Immutable */));
|
|
return {
|
|
getUnscopedHelperName,
|
|
createDecorateHelper,
|
|
createMetadataHelper,
|
|
createParamHelper,
|
|
createAssignHelper,
|
|
createAwaitHelper,
|
|
createAsyncGeneratorHelper,
|
|
createAsyncDelegatorHelper,
|
|
createAsyncValuesHelper,
|
|
createRestHelper,
|
|
createAwaiterHelper,
|
|
createExtendsHelper,
|
|
createTemplateObjectHelper,
|
|
createSpreadArrayHelper,
|
|
createValuesHelper,
|
|
createReadHelper,
|
|
createGeneratorHelper,
|
|
createCreateBindingHelper,
|
|
createImportStarHelper,
|
|
createImportStarCallbackHelper,
|
|
createImportDefaultHelper,
|
|
createExportStarHelper,
|
|
createClassPrivateFieldGetHelper,
|
|
createClassPrivateFieldSetHelper,
|
|
createClassPrivateFieldInHelper
|
|
};
|
|
function getUnscopedHelperName(name) {
|
|
return setEmitFlags(factory2.createIdentifier(name), 8192 /* HelperName */ | 4 /* AdviseOnEmitNode */);
|
|
}
|
|
function createDecorateHelper(decoratorExpressions, target, memberName, descriptor) {
|
|
context.requestEmitHelper(decorateHelper);
|
|
const argumentsArray = [];
|
|
argumentsArray.push(factory2.createArrayLiteralExpression(decoratorExpressions, true));
|
|
argumentsArray.push(target);
|
|
if (memberName) {
|
|
argumentsArray.push(memberName);
|
|
if (descriptor) {
|
|
argumentsArray.push(descriptor);
|
|
}
|
|
}
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__decorate"),
|
|
void 0,
|
|
argumentsArray
|
|
);
|
|
}
|
|
function createMetadataHelper(metadataKey, metadataValue) {
|
|
context.requestEmitHelper(metadataHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__metadata"),
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(metadataKey),
|
|
metadataValue
|
|
]
|
|
);
|
|
}
|
|
function createParamHelper(expression, parameterOffset, location) {
|
|
context.requestEmitHelper(paramHelper);
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
getUnscopedHelperName("__param"),
|
|
void 0,
|
|
[
|
|
factory2.createNumericLiteral(parameterOffset + ""),
|
|
expression
|
|
]
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createAssignHelper(attributesSegments) {
|
|
if (getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ES2015 */) {
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "assign"),
|
|
void 0,
|
|
attributesSegments
|
|
);
|
|
}
|
|
context.requestEmitHelper(assignHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__assign"),
|
|
void 0,
|
|
attributesSegments
|
|
);
|
|
}
|
|
function createAwaitHelper(expression) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
return factory2.createCallExpression(getUnscopedHelperName("__await"), void 0, [expression]);
|
|
}
|
|
function createAsyncGeneratorHelper(generatorFunc, hasLexicalThis) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
context.requestEmitHelper(asyncGeneratorHelper);
|
|
(generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 524288 /* AsyncFunctionBody */ | 1048576 /* ReuseTempVariableScope */;
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncGenerator"),
|
|
void 0,
|
|
[
|
|
hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
|
|
factory2.createIdentifier("arguments"),
|
|
generatorFunc
|
|
]
|
|
);
|
|
}
|
|
function createAsyncDelegatorHelper(expression) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
context.requestEmitHelper(asyncDelegator);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncDelegator"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createAsyncValuesHelper(expression) {
|
|
context.requestEmitHelper(asyncValues);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncValues"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createRestHelper(value, elements, computedTempVariables, location) {
|
|
context.requestEmitHelper(restHelper);
|
|
const propertyNames = [];
|
|
let computedTempVariableOffset = 0;
|
|
for (let i = 0; i < elements.length - 1; i++) {
|
|
const propertyName = getPropertyNameOfBindingOrAssignmentElement(elements[i]);
|
|
if (propertyName) {
|
|
if (isComputedPropertyName(propertyName)) {
|
|
Debug.assertIsDefined(computedTempVariables, "Encountered computed property name but 'computedTempVariables' argument was not provided.");
|
|
const temp = computedTempVariables[computedTempVariableOffset];
|
|
computedTempVariableOffset++;
|
|
propertyNames.push(
|
|
factory2.createConditionalExpression(
|
|
factory2.createTypeCheck(temp, "symbol"),
|
|
void 0,
|
|
temp,
|
|
void 0,
|
|
factory2.createAdd(temp, factory2.createStringLiteral(""))
|
|
)
|
|
);
|
|
} else {
|
|
propertyNames.push(factory2.createStringLiteralFromNode(propertyName));
|
|
}
|
|
}
|
|
}
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__rest"),
|
|
void 0,
|
|
[
|
|
value,
|
|
setTextRange(
|
|
factory2.createArrayLiteralExpression(propertyNames),
|
|
location
|
|
)
|
|
]
|
|
);
|
|
}
|
|
function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
|
|
context.requestEmitHelper(awaiterHelper);
|
|
const generatorFunc = factory2.createFunctionExpression(
|
|
void 0,
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
body
|
|
);
|
|
(generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 524288 /* AsyncFunctionBody */ | 1048576 /* ReuseTempVariableScope */;
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__awaiter"),
|
|
void 0,
|
|
[
|
|
hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
|
|
hasLexicalArguments ? factory2.createIdentifier("arguments") : factory2.createVoidZero(),
|
|
promiseConstructor ? createExpressionFromEntityName(factory2, promiseConstructor) : factory2.createVoidZero(),
|
|
generatorFunc
|
|
]
|
|
);
|
|
}
|
|
function createExtendsHelper(name) {
|
|
context.requestEmitHelper(extendsHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__extends"),
|
|
void 0,
|
|
[name, factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */)]
|
|
);
|
|
}
|
|
function createTemplateObjectHelper(cooked, raw) {
|
|
context.requestEmitHelper(templateObjectHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__makeTemplateObject"),
|
|
void 0,
|
|
[cooked, raw]
|
|
);
|
|
}
|
|
function createSpreadArrayHelper(to, from, packFrom) {
|
|
context.requestEmitHelper(spreadArrayHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__spreadArray"),
|
|
void 0,
|
|
[to, from, packFrom ? immutableTrue() : immutableFalse()]
|
|
);
|
|
}
|
|
function createValuesHelper(expression) {
|
|
context.requestEmitHelper(valuesHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__values"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createReadHelper(iteratorRecord, count) {
|
|
context.requestEmitHelper(readHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__read"),
|
|
void 0,
|
|
count !== void 0 ? [iteratorRecord, factory2.createNumericLiteral(count + "")] : [iteratorRecord]
|
|
);
|
|
}
|
|
function createGeneratorHelper(body) {
|
|
context.requestEmitHelper(generatorHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__generator"),
|
|
void 0,
|
|
[factory2.createThis(), body]
|
|
);
|
|
}
|
|
function createCreateBindingHelper(module2, inputName, outputName) {
|
|
context.requestEmitHelper(createBindingHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__createBinding"),
|
|
void 0,
|
|
[factory2.createIdentifier("exports"), module2, inputName, ...outputName ? [outputName] : []]
|
|
);
|
|
}
|
|
function createImportStarHelper(expression) {
|
|
context.requestEmitHelper(importStarHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__importStar"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createImportStarCallbackHelper() {
|
|
context.requestEmitHelper(importStarHelper);
|
|
return getUnscopedHelperName("__importStar");
|
|
}
|
|
function createImportDefaultHelper(expression) {
|
|
context.requestEmitHelper(importDefaultHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__importDefault"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createExportStarHelper(moduleExpression, exportsExpression = factory2.createIdentifier("exports")) {
|
|
context.requestEmitHelper(exportStarHelper);
|
|
context.requestEmitHelper(createBindingHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__exportStar"),
|
|
void 0,
|
|
[moduleExpression, exportsExpression]
|
|
);
|
|
}
|
|
function createClassPrivateFieldGetHelper(receiver, state, kind, f) {
|
|
context.requestEmitHelper(classPrivateFieldGetHelper);
|
|
let args;
|
|
if (!f) {
|
|
args = [receiver, state, factory2.createStringLiteral(kind)];
|
|
} else {
|
|
args = [receiver, state, factory2.createStringLiteral(kind), f];
|
|
}
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), void 0, args);
|
|
}
|
|
function createClassPrivateFieldSetHelper(receiver, state, value, kind, f) {
|
|
context.requestEmitHelper(classPrivateFieldSetHelper);
|
|
let args;
|
|
if (!f) {
|
|
args = [receiver, state, value, factory2.createStringLiteral(kind)];
|
|
} else {
|
|
args = [receiver, state, value, factory2.createStringLiteral(kind), f];
|
|
}
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), void 0, args);
|
|
}
|
|
function createClassPrivateFieldInHelper(state, receiver) {
|
|
context.requestEmitHelper(classPrivateFieldInHelper);
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), void 0, [state, receiver]);
|
|
}
|
|
}
|
|
function compareEmitHelpers(x, y) {
|
|
if (x === y)
|
|
return 0 /* EqualTo */;
|
|
if (x.priority === y.priority)
|
|
return 0 /* EqualTo */;
|
|
if (x.priority === void 0)
|
|
return 1 /* GreaterThan */;
|
|
if (y.priority === void 0)
|
|
return -1 /* LessThan */;
|
|
return compareValues(x.priority, y.priority);
|
|
}
|
|
function helperString(input, ...args) {
|
|
return (uniqueName) => {
|
|
let result = "";
|
|
for (let i = 0; i < args.length; i++) {
|
|
result += input[i];
|
|
result += uniqueName(args[i]);
|
|
}
|
|
result += input[input.length - 1];
|
|
return result;
|
|
};
|
|
}
|
|
var decorateHelper = {
|
|
name: "typescript:decorate",
|
|
importName: "__decorate",
|
|
scoped: false,
|
|
priority: 2,
|
|
text: `
|
|
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
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;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
};`
|
|
};
|
|
var metadataHelper = {
|
|
name: "typescript:metadata",
|
|
importName: "__metadata",
|
|
scoped: false,
|
|
priority: 3,
|
|
text: `
|
|
var __metadata = (this && this.__metadata) || function (k, v) {
|
|
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
|
|
};`
|
|
};
|
|
var paramHelper = {
|
|
name: "typescript:param",
|
|
importName: "__param",
|
|
scoped: false,
|
|
priority: 4,
|
|
text: `
|
|
var __param = (this && this.__param) || function (paramIndex, decorator) {
|
|
return function (target, key) { decorator(target, key, paramIndex); }
|
|
};`
|
|
};
|
|
var assignHelper = {
|
|
name: "typescript:assign",
|
|
importName: "__assign",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
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 awaitHelper = {
|
|
name: "typescript:await",
|
|
importName: "__await",
|
|
scoped: false,
|
|
text: `
|
|
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }`
|
|
};
|
|
var asyncGeneratorHelper = {
|
|
name: "typescript:asyncGenerator",
|
|
importName: "__asyncGenerator",
|
|
scoped: false,
|
|
dependencies: [awaitHelper],
|
|
text: `
|
|
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
|
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); }); }; }
|
|
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
|
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
|
function fulfill(value) { resume("next", value); }
|
|
function reject(value) { resume("throw", value); }
|
|
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
|
};`
|
|
};
|
|
var asyncDelegator = {
|
|
name: "typescript:asyncDelegator",
|
|
importName: "__asyncDelegator",
|
|
scoped: false,
|
|
dependencies: [awaitHelper],
|
|
text: `
|
|
var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
|
|
var i, p;
|
|
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
|
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
|
|
};`
|
|
};
|
|
var asyncValues = {
|
|
name: "typescript:asyncValues",
|
|
importName: "__asyncValues",
|
|
scoped: false,
|
|
text: `
|
|
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var m = o[Symbol.asyncIterator], i;
|
|
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);
|
|
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); }); }; }
|
|
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
|
};`
|
|
};
|
|
var restHelper = {
|
|
name: "typescript:rest",
|
|
importName: "__rest",
|
|
scoped: false,
|
|
text: `
|
|
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 awaiterHelper = {
|
|
name: "typescript:awaiter",
|
|
importName: "__awaiter",
|
|
scoped: false,
|
|
priority: 5,
|
|
text: `
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};`
|
|
};
|
|
var extendsHelper = {
|
|
name: "typescript:extends",
|
|
importName: "__extends",
|
|
scoped: false,
|
|
priority: 0,
|
|
text: `
|
|
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 templateObjectHelper = {
|
|
name: "typescript:makeTemplateObject",
|
|
importName: "__makeTemplateObject",
|
|
scoped: false,
|
|
priority: 0,
|
|
text: `
|
|
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
|
|
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
|
return cooked;
|
|
};`
|
|
};
|
|
var readHelper = {
|
|
name: "typescript:read",
|
|
importName: "__read",
|
|
scoped: false,
|
|
text: `
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};`
|
|
};
|
|
var spreadArrayHelper = {
|
|
name: "typescript:spreadArray",
|
|
importName: "__spreadArray",
|
|
scoped: false,
|
|
text: `
|
|
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 valuesHelper = {
|
|
name: "typescript:values",
|
|
importName: "__values",
|
|
scoped: false,
|
|
text: `
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};`
|
|
};
|
|
var generatorHelper = {
|
|
name: "typescript:generator",
|
|
importName: "__generator",
|
|
scoped: false,
|
|
priority: 6,
|
|
text: `
|
|
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 createBindingHelper = {
|
|
name: "typescript:commonjscreatebinding",
|
|
importName: "__createBinding",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));`
|
|
};
|
|
var setModuleDefaultHelper = {
|
|
name: "typescript:commonjscreatevalue",
|
|
importName: "__setModuleDefault",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});`
|
|
};
|
|
var importStarHelper = {
|
|
name: "typescript:commonjsimportstar",
|
|
importName: "__importStar",
|
|
scoped: false,
|
|
dependencies: [createBindingHelper, setModuleDefaultHelper],
|
|
priority: 2,
|
|
text: `
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};`
|
|
};
|
|
var importDefaultHelper = {
|
|
name: "typescript:commonjsimportdefault",
|
|
importName: "__importDefault",
|
|
scoped: false,
|
|
text: `
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};`
|
|
};
|
|
var exportStarHelper = {
|
|
name: "typescript:export-star",
|
|
importName: "__exportStar",
|
|
scoped: false,
|
|
dependencies: [createBindingHelper],
|
|
priority: 2,
|
|
text: `
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};`
|
|
};
|
|
var classPrivateFieldGetHelper = {
|
|
name: "typescript:classPrivateFieldGet",
|
|
importName: "__classPrivateFieldGet",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
|
|
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");
|
|
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
|
};`
|
|
};
|
|
var classPrivateFieldSetHelper = {
|
|
name: "typescript:classPrivateFieldSet",
|
|
importName: "__classPrivateFieldSet",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
|
|
if (kind === "m") throw new TypeError("Private method is not writable");
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
|
|
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");
|
|
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
|
|
};`
|
|
};
|
|
var classPrivateFieldInHelper = {
|
|
name: "typescript:classPrivateFieldIn",
|
|
importName: "__classPrivateFieldIn",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
|
|
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
|
|
return typeof state === "function" ? receiver === state : state.has(receiver);
|
|
};`
|
|
};
|
|
var allUnscopedEmitHelpers;
|
|
function getAllUnscopedEmitHelpers() {
|
|
return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = arrayToMap([
|
|
decorateHelper,
|
|
metadataHelper,
|
|
paramHelper,
|
|
assignHelper,
|
|
awaitHelper,
|
|
asyncGeneratorHelper,
|
|
asyncDelegator,
|
|
asyncValues,
|
|
restHelper,
|
|
awaiterHelper,
|
|
extendsHelper,
|
|
templateObjectHelper,
|
|
spreadArrayHelper,
|
|
valuesHelper,
|
|
readHelper,
|
|
generatorHelper,
|
|
importStarHelper,
|
|
importDefaultHelper,
|
|
exportStarHelper,
|
|
classPrivateFieldGetHelper,
|
|
classPrivateFieldSetHelper,
|
|
classPrivateFieldInHelper,
|
|
createBindingHelper,
|
|
setModuleDefaultHelper
|
|
], (helper) => helper.name));
|
|
}
|
|
var asyncSuperHelper = {
|
|
name: "typescript:async-super",
|
|
scoped: true,
|
|
text: helperString`
|
|
const ${"_superIndex"} = name => super[name];`
|
|
};
|
|
var advancedAsyncSuperHelper = {
|
|
name: "typescript:advanced-async-super",
|
|
scoped: true,
|
|
text: helperString`
|
|
const ${"_superIndex"} = (function (geti, seti) {
|
|
const cache = Object.create(null);
|
|
return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });
|
|
})(name => super[name], (name, value) => super[name] = value);`
|
|
};
|
|
function isCallToHelper(firstSegment, helperName) {
|
|
return isCallExpression(firstSegment) && isIdentifier(firstSegment.expression) && (getEmitFlags(firstSegment.expression) & 8192 /* HelperName */) !== 0 && firstSegment.expression.escapedText === helperName;
|
|
}
|
|
|
|
// src/compiler/factory/nodeTests.ts
|
|
function isNumericLiteral(node) {
|
|
return node.kind === 8 /* NumericLiteral */;
|
|
}
|
|
function isBigIntLiteral(node) {
|
|
return node.kind === 9 /* BigIntLiteral */;
|
|
}
|
|
function isStringLiteral(node) {
|
|
return node.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isJsxText(node) {
|
|
return node.kind === 11 /* JsxText */;
|
|
}
|
|
function isNoSubstitutionTemplateLiteral(node) {
|
|
return node.kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isTemplateHead(node) {
|
|
return node.kind === 15 /* TemplateHead */;
|
|
}
|
|
function isDotDotDotToken(node) {
|
|
return node.kind === 25 /* DotDotDotToken */;
|
|
}
|
|
function isCommaToken(node) {
|
|
return node.kind === 27 /* CommaToken */;
|
|
}
|
|
function isPlusToken(node) {
|
|
return node.kind === 39 /* PlusToken */;
|
|
}
|
|
function isMinusToken(node) {
|
|
return node.kind === 40 /* MinusToken */;
|
|
}
|
|
function isAsteriskToken(node) {
|
|
return node.kind === 41 /* AsteriskToken */;
|
|
}
|
|
function isExclamationToken(node) {
|
|
return node.kind === 53 /* ExclamationToken */;
|
|
}
|
|
function isQuestionToken(node) {
|
|
return node.kind === 57 /* QuestionToken */;
|
|
}
|
|
function isColonToken(node) {
|
|
return node.kind === 58 /* ColonToken */;
|
|
}
|
|
function isQuestionDotToken(node) {
|
|
return node.kind === 28 /* QuestionDotToken */;
|
|
}
|
|
function isEqualsGreaterThanToken(node) {
|
|
return node.kind === 38 /* EqualsGreaterThanToken */;
|
|
}
|
|
function isIdentifier(node) {
|
|
return node.kind === 79 /* Identifier */;
|
|
}
|
|
function isPrivateIdentifier(node) {
|
|
return node.kind === 80 /* PrivateIdentifier */;
|
|
}
|
|
function isExportModifier(node) {
|
|
return node.kind === 93 /* ExportKeyword */;
|
|
}
|
|
function isAsyncModifier(node) {
|
|
return node.kind === 132 /* AsyncKeyword */;
|
|
}
|
|
function isAssertsKeyword(node) {
|
|
return node.kind === 129 /* AssertsKeyword */;
|
|
}
|
|
function isAwaitKeyword(node) {
|
|
return node.kind === 133 /* AwaitKeyword */;
|
|
}
|
|
function isReadonlyKeyword(node) {
|
|
return node.kind === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function isStaticModifier(node) {
|
|
return node.kind === 124 /* StaticKeyword */;
|
|
}
|
|
function isAccessorModifier(node) {
|
|
return node.kind === 127 /* AccessorKeyword */;
|
|
}
|
|
function isSuperKeyword(node) {
|
|
return node.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isImportKeyword(node) {
|
|
return node.kind === 100 /* ImportKeyword */;
|
|
}
|
|
function isQualifiedName(node) {
|
|
return node.kind === 163 /* QualifiedName */;
|
|
}
|
|
function isComputedPropertyName(node) {
|
|
return node.kind === 164 /* ComputedPropertyName */;
|
|
}
|
|
function isTypeParameterDeclaration(node) {
|
|
return node.kind === 165 /* TypeParameter */;
|
|
}
|
|
function isParameter(node) {
|
|
return node.kind === 166 /* Parameter */;
|
|
}
|
|
function isDecorator(node) {
|
|
return node.kind === 167 /* Decorator */;
|
|
}
|
|
function isPropertySignature(node) {
|
|
return node.kind === 168 /* PropertySignature */;
|
|
}
|
|
function isPropertyDeclaration(node) {
|
|
return node.kind === 169 /* PropertyDeclaration */;
|
|
}
|
|
function isMethodSignature(node) {
|
|
return node.kind === 170 /* MethodSignature */;
|
|
}
|
|
function isMethodDeclaration(node) {
|
|
return node.kind === 171 /* MethodDeclaration */;
|
|
}
|
|
function isClassStaticBlockDeclaration(node) {
|
|
return node.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
}
|
|
function isConstructorDeclaration(node) {
|
|
return node.kind === 173 /* Constructor */;
|
|
}
|
|
function isGetAccessorDeclaration(node) {
|
|
return node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function isSetAccessorDeclaration(node) {
|
|
return node.kind === 175 /* SetAccessor */;
|
|
}
|
|
function isCallSignatureDeclaration(node) {
|
|
return node.kind === 176 /* CallSignature */;
|
|
}
|
|
function isConstructSignatureDeclaration(node) {
|
|
return node.kind === 177 /* ConstructSignature */;
|
|
}
|
|
function isIndexSignatureDeclaration(node) {
|
|
return node.kind === 178 /* IndexSignature */;
|
|
}
|
|
function isTypePredicateNode(node) {
|
|
return node.kind === 179 /* TypePredicate */;
|
|
}
|
|
function isTypeReferenceNode(node) {
|
|
return node.kind === 180 /* TypeReference */;
|
|
}
|
|
function isFunctionTypeNode(node) {
|
|
return node.kind === 181 /* FunctionType */;
|
|
}
|
|
function isConstructorTypeNode(node) {
|
|
return node.kind === 182 /* ConstructorType */;
|
|
}
|
|
function isTypeQueryNode(node) {
|
|
return node.kind === 183 /* TypeQuery */;
|
|
}
|
|
function isTypeLiteralNode(node) {
|
|
return node.kind === 184 /* TypeLiteral */;
|
|
}
|
|
function isArrayTypeNode(node) {
|
|
return node.kind === 185 /* ArrayType */;
|
|
}
|
|
function isTupleTypeNode(node) {
|
|
return node.kind === 186 /* TupleType */;
|
|
}
|
|
function isNamedTupleMember(node) {
|
|
return node.kind === 199 /* NamedTupleMember */;
|
|
}
|
|
function isOptionalTypeNode(node) {
|
|
return node.kind === 187 /* OptionalType */;
|
|
}
|
|
function isRestTypeNode(node) {
|
|
return node.kind === 188 /* RestType */;
|
|
}
|
|
function isUnionTypeNode(node) {
|
|
return node.kind === 189 /* UnionType */;
|
|
}
|
|
function isIntersectionTypeNode(node) {
|
|
return node.kind === 190 /* IntersectionType */;
|
|
}
|
|
function isConditionalTypeNode(node) {
|
|
return node.kind === 191 /* ConditionalType */;
|
|
}
|
|
function isInferTypeNode(node) {
|
|
return node.kind === 192 /* InferType */;
|
|
}
|
|
function isParenthesizedTypeNode(node) {
|
|
return node.kind === 193 /* ParenthesizedType */;
|
|
}
|
|
function isThisTypeNode(node) {
|
|
return node.kind === 194 /* ThisType */;
|
|
}
|
|
function isTypeOperatorNode(node) {
|
|
return node.kind === 195 /* TypeOperator */;
|
|
}
|
|
function isIndexedAccessTypeNode(node) {
|
|
return node.kind === 196 /* IndexedAccessType */;
|
|
}
|
|
function isMappedTypeNode(node) {
|
|
return node.kind === 197 /* MappedType */;
|
|
}
|
|
function isLiteralTypeNode(node) {
|
|
return node.kind === 198 /* LiteralType */;
|
|
}
|
|
function isImportTypeNode(node) {
|
|
return node.kind === 202 /* ImportType */;
|
|
}
|
|
function isTemplateLiteralTypeSpan(node) {
|
|
return node.kind === 201 /* TemplateLiteralTypeSpan */;
|
|
}
|
|
function isObjectBindingPattern(node) {
|
|
return node.kind === 203 /* ObjectBindingPattern */;
|
|
}
|
|
function isArrayBindingPattern(node) {
|
|
return node.kind === 204 /* ArrayBindingPattern */;
|
|
}
|
|
function isBindingElement(node) {
|
|
return node.kind === 205 /* BindingElement */;
|
|
}
|
|
function isArrayLiteralExpression(node) {
|
|
return node.kind === 206 /* ArrayLiteralExpression */;
|
|
}
|
|
function isObjectLiteralExpression(node) {
|
|
return node.kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isPropertyAccessExpression(node) {
|
|
return node.kind === 208 /* PropertyAccessExpression */;
|
|
}
|
|
function isElementAccessExpression(node) {
|
|
return node.kind === 209 /* ElementAccessExpression */;
|
|
}
|
|
function isCallExpression(node) {
|
|
return node.kind === 210 /* CallExpression */;
|
|
}
|
|
function isNewExpression(node) {
|
|
return node.kind === 211 /* NewExpression */;
|
|
}
|
|
function isTaggedTemplateExpression(node) {
|
|
return node.kind === 212 /* TaggedTemplateExpression */;
|
|
}
|
|
function isParenthesizedExpression(node) {
|
|
return node.kind === 214 /* ParenthesizedExpression */;
|
|
}
|
|
function isFunctionExpression(node) {
|
|
return node.kind === 215 /* FunctionExpression */;
|
|
}
|
|
function isArrowFunction(node) {
|
|
return node.kind === 216 /* ArrowFunction */;
|
|
}
|
|
function isTypeOfExpression(node) {
|
|
return node.kind === 218 /* TypeOfExpression */;
|
|
}
|
|
function isVoidExpression(node) {
|
|
return node.kind === 219 /* VoidExpression */;
|
|
}
|
|
function isPrefixUnaryExpression(node) {
|
|
return node.kind === 221 /* PrefixUnaryExpression */;
|
|
}
|
|
function isPostfixUnaryExpression(node) {
|
|
return node.kind === 222 /* PostfixUnaryExpression */;
|
|
}
|
|
function isBinaryExpression(node) {
|
|
return node.kind === 223 /* BinaryExpression */;
|
|
}
|
|
function isConditionalExpression(node) {
|
|
return node.kind === 224 /* ConditionalExpression */;
|
|
}
|
|
function isSpreadElement(node) {
|
|
return node.kind === 227 /* SpreadElement */;
|
|
}
|
|
function isClassExpression(node) {
|
|
return node.kind === 228 /* ClassExpression */;
|
|
}
|
|
function isOmittedExpression(node) {
|
|
return node.kind === 229 /* OmittedExpression */;
|
|
}
|
|
function isExpressionWithTypeArguments(node) {
|
|
return node.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
function isNonNullExpression(node) {
|
|
return node.kind === 232 /* NonNullExpression */;
|
|
}
|
|
function isMetaProperty(node) {
|
|
return node.kind === 233 /* MetaProperty */;
|
|
}
|
|
function isPartiallyEmittedExpression(node) {
|
|
return node.kind === 353 /* PartiallyEmittedExpression */;
|
|
}
|
|
function isCommaListExpression(node) {
|
|
return node.kind === 354 /* CommaListExpression */;
|
|
}
|
|
function isTemplateSpan(node) {
|
|
return node.kind === 236 /* TemplateSpan */;
|
|
}
|
|
function isSemicolonClassElement(node) {
|
|
return node.kind === 237 /* SemicolonClassElement */;
|
|
}
|
|
function isBlock(node) {
|
|
return node.kind === 238 /* Block */;
|
|
}
|
|
function isVariableStatement(node) {
|
|
return node.kind === 240 /* VariableStatement */;
|
|
}
|
|
function isEmptyStatement(node) {
|
|
return node.kind === 239 /* EmptyStatement */;
|
|
}
|
|
function isExpressionStatement(node) {
|
|
return node.kind === 241 /* ExpressionStatement */;
|
|
}
|
|
function isIfStatement(node) {
|
|
return node.kind === 242 /* IfStatement */;
|
|
}
|
|
function isForStatement(node) {
|
|
return node.kind === 245 /* ForStatement */;
|
|
}
|
|
function isForInStatement(node) {
|
|
return node.kind === 246 /* ForInStatement */;
|
|
}
|
|
function isForOfStatement(node) {
|
|
return node.kind === 247 /* ForOfStatement */;
|
|
}
|
|
function isReturnStatement(node) {
|
|
return node.kind === 250 /* ReturnStatement */;
|
|
}
|
|
function isWithStatement(node) {
|
|
return node.kind === 251 /* WithStatement */;
|
|
}
|
|
function isSwitchStatement(node) {
|
|
return node.kind === 252 /* SwitchStatement */;
|
|
}
|
|
function isLabeledStatement(node) {
|
|
return node.kind === 253 /* LabeledStatement */;
|
|
}
|
|
function isTryStatement(node) {
|
|
return node.kind === 255 /* TryStatement */;
|
|
}
|
|
function isVariableDeclaration(node) {
|
|
return node.kind === 257 /* VariableDeclaration */;
|
|
}
|
|
function isVariableDeclarationList(node) {
|
|
return node.kind === 258 /* VariableDeclarationList */;
|
|
}
|
|
function isFunctionDeclaration(node) {
|
|
return node.kind === 259 /* FunctionDeclaration */;
|
|
}
|
|
function isClassDeclaration(node) {
|
|
return node.kind === 260 /* ClassDeclaration */;
|
|
}
|
|
function isInterfaceDeclaration(node) {
|
|
return node.kind === 261 /* InterfaceDeclaration */;
|
|
}
|
|
function isTypeAliasDeclaration(node) {
|
|
return node.kind === 262 /* TypeAliasDeclaration */;
|
|
}
|
|
function isEnumDeclaration(node) {
|
|
return node.kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function isModuleDeclaration(node) {
|
|
return node.kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isModuleBlock(node) {
|
|
return node.kind === 265 /* ModuleBlock */;
|
|
}
|
|
function isCaseBlock(node) {
|
|
return node.kind === 266 /* CaseBlock */;
|
|
}
|
|
function isNamespaceExportDeclaration(node) {
|
|
return node.kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
function isImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */;
|
|
}
|
|
function isImportDeclaration(node) {
|
|
return node.kind === 269 /* ImportDeclaration */;
|
|
}
|
|
function isImportClause(node) {
|
|
return node.kind === 270 /* ImportClause */;
|
|
}
|
|
function isImportTypeAssertionContainer(node) {
|
|
return node.kind === 298 /* ImportTypeAssertionContainer */;
|
|
}
|
|
function isAssertClause(node) {
|
|
return node.kind === 296 /* AssertClause */;
|
|
}
|
|
function isAssertEntry(node) {
|
|
return node.kind === 297 /* AssertEntry */;
|
|
}
|
|
function isNamespaceImport(node) {
|
|
return node.kind === 271 /* NamespaceImport */;
|
|
}
|
|
function isNamespaceExport(node) {
|
|
return node.kind === 277 /* NamespaceExport */;
|
|
}
|
|
function isNamedImports(node) {
|
|
return node.kind === 272 /* NamedImports */;
|
|
}
|
|
function isImportSpecifier(node) {
|
|
return node.kind === 273 /* ImportSpecifier */;
|
|
}
|
|
function isExportAssignment(node) {
|
|
return node.kind === 274 /* ExportAssignment */;
|
|
}
|
|
function isExportDeclaration(node) {
|
|
return node.kind === 275 /* ExportDeclaration */;
|
|
}
|
|
function isNamedExports(node) {
|
|
return node.kind === 276 /* NamedExports */;
|
|
}
|
|
function isExportSpecifier(node) {
|
|
return node.kind === 278 /* ExportSpecifier */;
|
|
}
|
|
function isNotEmittedStatement(node) {
|
|
return node.kind === 352 /* NotEmittedStatement */;
|
|
}
|
|
function isSyntheticReference(node) {
|
|
return node.kind === 357 /* SyntheticReferenceExpression */;
|
|
}
|
|
function isExternalModuleReference(node) {
|
|
return node.kind === 280 /* ExternalModuleReference */;
|
|
}
|
|
function isJsxElement(node) {
|
|
return node.kind === 281 /* JsxElement */;
|
|
}
|
|
function isJsxSelfClosingElement(node) {
|
|
return node.kind === 282 /* JsxSelfClosingElement */;
|
|
}
|
|
function isJsxOpeningElement(node) {
|
|
return node.kind === 283 /* JsxOpeningElement */;
|
|
}
|
|
function isJsxClosingElement(node) {
|
|
return node.kind === 284 /* JsxClosingElement */;
|
|
}
|
|
function isJsxFragment(node) {
|
|
return node.kind === 285 /* JsxFragment */;
|
|
}
|
|
function isJsxOpeningFragment(node) {
|
|
return node.kind === 286 /* JsxOpeningFragment */;
|
|
}
|
|
function isJsxClosingFragment(node) {
|
|
return node.kind === 287 /* JsxClosingFragment */;
|
|
}
|
|
function isJsxAttribute(node) {
|
|
return node.kind === 288 /* JsxAttribute */;
|
|
}
|
|
function isJsxAttributes(node) {
|
|
return node.kind === 289 /* JsxAttributes */;
|
|
}
|
|
function isJsxSpreadAttribute(node) {
|
|
return node.kind === 290 /* JsxSpreadAttribute */;
|
|
}
|
|
function isCaseClause(node) {
|
|
return node.kind === 292 /* CaseClause */;
|
|
}
|
|
function isDefaultClause(node) {
|
|
return node.kind === 293 /* DefaultClause */;
|
|
}
|
|
function isHeritageClause(node) {
|
|
return node.kind === 294 /* HeritageClause */;
|
|
}
|
|
function isCatchClause(node) {
|
|
return node.kind === 295 /* CatchClause */;
|
|
}
|
|
function isPropertyAssignment(node) {
|
|
return node.kind === 299 /* PropertyAssignment */;
|
|
}
|
|
function isShorthandPropertyAssignment(node) {
|
|
return node.kind === 300 /* ShorthandPropertyAssignment */;
|
|
}
|
|
function isSpreadAssignment(node) {
|
|
return node.kind === 301 /* SpreadAssignment */;
|
|
}
|
|
function isEnumMember(node) {
|
|
return node.kind === 302 /* EnumMember */;
|
|
}
|
|
function isUnparsedPrepend(node) {
|
|
return node.kind === 304 /* UnparsedPrepend */;
|
|
}
|
|
function isSourceFile(node) {
|
|
return node.kind === 308 /* SourceFile */;
|
|
}
|
|
function isBundle(node) {
|
|
return node.kind === 309 /* Bundle */;
|
|
}
|
|
function isUnparsedSource(node) {
|
|
return node.kind === 310 /* UnparsedSource */;
|
|
}
|
|
function isJSDocTypeExpression(node) {
|
|
return node.kind === 312 /* JSDocTypeExpression */;
|
|
}
|
|
function isJSDocNameReference(node) {
|
|
return node.kind === 313 /* JSDocNameReference */;
|
|
}
|
|
function isJSDocMemberName(node) {
|
|
return node.kind === 314 /* JSDocMemberName */;
|
|
}
|
|
function isJSDocAllType(node) {
|
|
return node.kind === 315 /* JSDocAllType */;
|
|
}
|
|
function isJSDocUnknownType(node) {
|
|
return node.kind === 316 /* JSDocUnknownType */;
|
|
}
|
|
function isJSDocNullableType(node) {
|
|
return node.kind === 317 /* JSDocNullableType */;
|
|
}
|
|
function isJSDocNonNullableType(node) {
|
|
return node.kind === 318 /* JSDocNonNullableType */;
|
|
}
|
|
function isJSDocOptionalType(node) {
|
|
return node.kind === 319 /* JSDocOptionalType */;
|
|
}
|
|
function isJSDocFunctionType(node) {
|
|
return node.kind === 320 /* JSDocFunctionType */;
|
|
}
|
|
function isJSDocVariadicType(node) {
|
|
return node.kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
function isJSDoc(node) {
|
|
return node.kind === 323 /* JSDoc */;
|
|
}
|
|
function isJSDocTypeLiteral(node) {
|
|
return node.kind === 325 /* JSDocTypeLiteral */;
|
|
}
|
|
function isJSDocSignature(node) {
|
|
return node.kind === 326 /* JSDocSignature */;
|
|
}
|
|
function isJSDocAugmentsTag(node) {
|
|
return node.kind === 331 /* JSDocAugmentsTag */;
|
|
}
|
|
function isJSDocClassTag(node) {
|
|
return node.kind === 335 /* JSDocClassTag */;
|
|
}
|
|
function isJSDocCallbackTag(node) {
|
|
return node.kind === 341 /* JSDocCallbackTag */;
|
|
}
|
|
function isJSDocPublicTag(node) {
|
|
return node.kind === 336 /* JSDocPublicTag */;
|
|
}
|
|
function isJSDocPrivateTag(node) {
|
|
return node.kind === 337 /* JSDocPrivateTag */;
|
|
}
|
|
function isJSDocProtectedTag(node) {
|
|
return node.kind === 338 /* JSDocProtectedTag */;
|
|
}
|
|
function isJSDocReadonlyTag(node) {
|
|
return node.kind === 339 /* JSDocReadonlyTag */;
|
|
}
|
|
function isJSDocOverrideTag(node) {
|
|
return node.kind === 340 /* JSDocOverrideTag */;
|
|
}
|
|
function isJSDocDeprecatedTag(node) {
|
|
return node.kind === 334 /* JSDocDeprecatedTag */;
|
|
}
|
|
function isJSDocEnumTag(node) {
|
|
return node.kind === 342 /* JSDocEnumTag */;
|
|
}
|
|
function isJSDocParameterTag(node) {
|
|
return node.kind === 343 /* JSDocParameterTag */;
|
|
}
|
|
function isJSDocReturnTag(node) {
|
|
return node.kind === 344 /* JSDocReturnTag */;
|
|
}
|
|
function isJSDocThisTag(node) {
|
|
return node.kind === 345 /* JSDocThisTag */;
|
|
}
|
|
function isJSDocTypeTag(node) {
|
|
return node.kind === 346 /* JSDocTypeTag */;
|
|
}
|
|
function isJSDocTemplateTag(node) {
|
|
return node.kind === 347 /* JSDocTemplateTag */;
|
|
}
|
|
function isJSDocTypedefTag(node) {
|
|
return node.kind === 348 /* JSDocTypedefTag */;
|
|
}
|
|
function isJSDocImplementsTag(node) {
|
|
return node.kind === 332 /* JSDocImplementsTag */;
|
|
}
|
|
|
|
// src/compiler/factory/utilities.ts
|
|
function createEmptyExports(factory2) {
|
|
return factory2.createExportDeclaration(void 0, false, factory2.createNamedExports([]), void 0);
|
|
}
|
|
function createMemberAccessForPropertyName(factory2, target, memberName, location) {
|
|
if (isComputedPropertyName(memberName)) {
|
|
return setTextRange(factory2.createElementAccessExpression(target, memberName.expression), location);
|
|
} else {
|
|
const expression = setTextRange(
|
|
isMemberName(memberName) ? factory2.createPropertyAccessExpression(target, memberName) : factory2.createElementAccessExpression(target, memberName),
|
|
memberName
|
|
);
|
|
getOrCreateEmitNode(expression).flags |= 128 /* NoNestedSourceMaps */;
|
|
return expression;
|
|
}
|
|
}
|
|
function createReactNamespace(reactNamespace, parent) {
|
|
const react = parseNodeFactory.createIdentifier(reactNamespace || "React");
|
|
setParent(react, getParseTreeNode(parent));
|
|
return react;
|
|
}
|
|
function createJsxFactoryExpressionFromEntityName(factory2, jsxFactory, parent) {
|
|
if (isQualifiedName(jsxFactory)) {
|
|
const left = createJsxFactoryExpressionFromEntityName(factory2, jsxFactory.left, parent);
|
|
const right = factory2.createIdentifier(idText(jsxFactory.right));
|
|
right.escapedText = jsxFactory.right.escapedText;
|
|
return factory2.createPropertyAccessExpression(left, right);
|
|
} else {
|
|
return createReactNamespace(idText(jsxFactory), parent);
|
|
}
|
|
}
|
|
function createJsxFactoryExpression(factory2, jsxFactoryEntity, reactNamespace, parent) {
|
|
return jsxFactoryEntity ? createJsxFactoryExpressionFromEntityName(factory2, jsxFactoryEntity, parent) : factory2.createPropertyAccessExpression(
|
|
createReactNamespace(reactNamespace, parent),
|
|
"createElement"
|
|
);
|
|
}
|
|
function createJsxFragmentFactoryExpression(factory2, jsxFragmentFactoryEntity, reactNamespace, parent) {
|
|
return jsxFragmentFactoryEntity ? createJsxFactoryExpressionFromEntityName(factory2, jsxFragmentFactoryEntity, parent) : factory2.createPropertyAccessExpression(
|
|
createReactNamespace(reactNamespace, parent),
|
|
"Fragment"
|
|
);
|
|
}
|
|
function createExpressionForJsxElement(factory2, callee, tagName, props, children, location) {
|
|
const argumentsList = [tagName];
|
|
if (props) {
|
|
argumentsList.push(props);
|
|
}
|
|
if (children && children.length > 0) {
|
|
if (!props) {
|
|
argumentsList.push(factory2.createNull());
|
|
}
|
|
if (children.length > 1) {
|
|
for (const child of children) {
|
|
startOnNewLine(child);
|
|
argumentsList.push(child);
|
|
}
|
|
} else {
|
|
argumentsList.push(children[0]);
|
|
}
|
|
}
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
callee,
|
|
void 0,
|
|
argumentsList
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createExpressionForJsxFragment(factory2, jsxFactoryEntity, jsxFragmentFactoryEntity, reactNamespace, children, parentElement, location) {
|
|
const tagName = createJsxFragmentFactoryExpression(factory2, jsxFragmentFactoryEntity, reactNamespace, parentElement);
|
|
const argumentsList = [tagName, factory2.createNull()];
|
|
if (children && children.length > 0) {
|
|
if (children.length > 1) {
|
|
for (const child of children) {
|
|
startOnNewLine(child);
|
|
argumentsList.push(child);
|
|
}
|
|
} else {
|
|
argumentsList.push(children[0]);
|
|
}
|
|
}
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
createJsxFactoryExpression(factory2, jsxFactoryEntity, reactNamespace, parentElement),
|
|
void 0,
|
|
argumentsList
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createForOfBindingStatement(factory2, node, boundValue) {
|
|
if (isVariableDeclarationList(node)) {
|
|
const firstDeclaration = first(node.declarations);
|
|
const updatedDeclaration = factory2.updateVariableDeclaration(
|
|
firstDeclaration,
|
|
firstDeclaration.name,
|
|
void 0,
|
|
void 0,
|
|
boundValue
|
|
);
|
|
return setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.updateVariableDeclarationList(node, [updatedDeclaration])
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const updatedExpression = setTextRange(factory2.createAssignment(node, boundValue), node);
|
|
return setTextRange(factory2.createExpressionStatement(updatedExpression), node);
|
|
}
|
|
}
|
|
function createExpressionFromEntityName(factory2, node) {
|
|
if (isQualifiedName(node)) {
|
|
const left = createExpressionFromEntityName(factory2, node.left);
|
|
const right = setParent(setTextRange(factory2.cloneNode(node.right), node.right), node.right.parent);
|
|
return setTextRange(factory2.createPropertyAccessExpression(left, right), node);
|
|
} else {
|
|
return setParent(setTextRange(factory2.cloneNode(node), node), node.parent);
|
|
}
|
|
}
|
|
function createExpressionForPropertyName(factory2, memberName) {
|
|
if (isIdentifier(memberName)) {
|
|
return factory2.createStringLiteralFromNode(memberName);
|
|
} else if (isComputedPropertyName(memberName)) {
|
|
return setParent(setTextRange(factory2.cloneNode(memberName.expression), memberName.expression), memberName.expression.parent);
|
|
} else {
|
|
return setParent(setTextRange(factory2.cloneNode(memberName), memberName), memberName.parent);
|
|
}
|
|
}
|
|
function createExpressionForAccessorDeclaration(factory2, properties, property, receiver, multiLine) {
|
|
const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property);
|
|
if (property === firstAccessor) {
|
|
return setTextRange(
|
|
factory2.createObjectDefinePropertyCall(
|
|
receiver,
|
|
createExpressionForPropertyName(factory2, property.name),
|
|
factory2.createPropertyDescriptor({
|
|
enumerable: factory2.createFalse(),
|
|
configurable: true,
|
|
get: getAccessor && setTextRange(
|
|
setOriginalNode(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(getAccessor),
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
getAccessor.parameters,
|
|
void 0,
|
|
getAccessor.body
|
|
),
|
|
getAccessor
|
|
),
|
|
getAccessor
|
|
),
|
|
set: setAccessor && setTextRange(
|
|
setOriginalNode(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(setAccessor),
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
setAccessor.parameters,
|
|
void 0,
|
|
setAccessor.body
|
|
),
|
|
setAccessor
|
|
),
|
|
setAccessor
|
|
)
|
|
}, !multiLine)
|
|
),
|
|
firstAccessor
|
|
);
|
|
}
|
|
return void 0;
|
|
}
|
|
function createExpressionForPropertyAssignment(factory2, property, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, property.name, property.name),
|
|
property.initializer
|
|
),
|
|
property
|
|
),
|
|
property
|
|
);
|
|
}
|
|
function createExpressionForShorthandPropertyAssignment(factory2, property, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, property.name, property.name),
|
|
factory2.cloneNode(property.name)
|
|
),
|
|
property
|
|
),
|
|
property
|
|
);
|
|
}
|
|
function createExpressionForMethodDeclaration(factory2, method, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, method.name, method.name),
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(method),
|
|
method.asteriskToken,
|
|
void 0,
|
|
void 0,
|
|
method.parameters,
|
|
void 0,
|
|
method.body
|
|
),
|
|
method
|
|
),
|
|
method
|
|
)
|
|
),
|
|
method
|
|
),
|
|
method
|
|
);
|
|
}
|
|
function createExpressionForObjectLiteralElementLike(factory2, node, property, receiver) {
|
|
if (property.name && isPrivateIdentifier(property.name)) {
|
|
Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals.");
|
|
}
|
|
switch (property.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return createExpressionForAccessorDeclaration(factory2, node.properties, property, receiver, !!node.multiLine);
|
|
case 299 /* PropertyAssignment */:
|
|
return createExpressionForPropertyAssignment(factory2, property, receiver);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return createExpressionForShorthandPropertyAssignment(factory2, property, receiver);
|
|
case 171 /* MethodDeclaration */:
|
|
return createExpressionForMethodDeclaration(factory2, property, receiver);
|
|
}
|
|
}
|
|
function expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, recordTempVariable, resultVariable) {
|
|
const operator = node.operator;
|
|
Debug.assert(operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */, "Expected 'node' to be a pre- or post-increment or pre- or post-decrement expression");
|
|
const temp = factory2.createTempVariable(recordTempVariable);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node.operand);
|
|
let operation = isPrefixUnaryExpression(node) ? factory2.createPrefixUnaryExpression(operator, temp) : factory2.createPostfixUnaryExpression(temp, operator);
|
|
setTextRange(operation, node);
|
|
if (resultVariable) {
|
|
operation = factory2.createAssignment(resultVariable, operation);
|
|
setTextRange(operation, node);
|
|
}
|
|
expression = factory2.createComma(expression, operation);
|
|
setTextRange(expression, node);
|
|
if (isPostfixUnaryExpression(node)) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
function isInternalName(node) {
|
|
return (getEmitFlags(node) & 65536 /* InternalName */) !== 0;
|
|
}
|
|
function isLocalName(node) {
|
|
return (getEmitFlags(node) & 32768 /* LocalName */) !== 0;
|
|
}
|
|
function isExportName(node) {
|
|
return (getEmitFlags(node) & 16384 /* ExportName */) !== 0;
|
|
}
|
|
function isUseStrictPrologue(node) {
|
|
return isStringLiteral(node.expression) && node.expression.text === "use strict";
|
|
}
|
|
function findUseStrictPrologue(statements) {
|
|
for (const statement of statements) {
|
|
if (isPrologueDirective(statement)) {
|
|
if (isUseStrictPrologue(statement)) {
|
|
return statement;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function startsWithUseStrict(statements) {
|
|
const firstStatement = firstOrUndefined(statements);
|
|
return firstStatement !== void 0 && isPrologueDirective(firstStatement) && isUseStrictPrologue(firstStatement);
|
|
}
|
|
function isCommaSequence(node) {
|
|
return node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 27 /* CommaToken */ || node.kind === 354 /* CommaListExpression */;
|
|
}
|
|
function isJSDocTypeAssertion(node) {
|
|
return isParenthesizedExpression(node) && isInJSFile(node) && !!getJSDocTypeTag(node);
|
|
}
|
|
function getJSDocTypeAssertionType(node) {
|
|
const type = getJSDocType(node);
|
|
Debug.assertIsDefined(type);
|
|
return type;
|
|
}
|
|
function isOuterExpression(node, kinds = 15 /* All */) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
if (kinds & 16 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
|
|
return false;
|
|
}
|
|
return (kinds & 1 /* Parentheses */) !== 0;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return (kinds & 2 /* TypeAssertions */) !== 0;
|
|
case 232 /* NonNullExpression */:
|
|
return (kinds & 4 /* NonNullAssertions */) !== 0;
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0;
|
|
}
|
|
return false;
|
|
}
|
|
function skipOuterExpressions(node, kinds = 15 /* All */) {
|
|
while (isOuterExpression(node, kinds)) {
|
|
node = node.expression;
|
|
}
|
|
return node;
|
|
}
|
|
function startOnNewLine(node) {
|
|
return setStartsOnNewLine(node, true);
|
|
}
|
|
function getExternalHelpersModuleName(node) {
|
|
const parseNode = getOriginalNode(node, isSourceFile);
|
|
const emitNode = parseNode && parseNode.emitNode;
|
|
return emitNode && emitNode.externalHelpersModuleName;
|
|
}
|
|
function hasRecordedExternalHelpers(sourceFile) {
|
|
const parseNode = getOriginalNode(sourceFile, isSourceFile);
|
|
const emitNode = parseNode && parseNode.emitNode;
|
|
return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers);
|
|
}
|
|
function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) {
|
|
if (compilerOptions.importHelpers && isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
let namedBindings;
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || sourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
const helpers = getEmitHelpers(sourceFile);
|
|
if (helpers) {
|
|
const helperNames = [];
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
const importName = helper.importName;
|
|
if (importName) {
|
|
pushIfUnique(helperNames, importName);
|
|
}
|
|
}
|
|
}
|
|
if (some(helperNames)) {
|
|
helperNames.sort(compareStringsCaseSensitive);
|
|
namedBindings = nodeFactory.createNamedImports(
|
|
map(
|
|
helperNames,
|
|
(name) => isFileLevelUniqueName(sourceFile, name) ? nodeFactory.createImportSpecifier(false, void 0, nodeFactory.createIdentifier(name)) : nodeFactory.createImportSpecifier(false, nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name))
|
|
)
|
|
);
|
|
const parseNode = getOriginalNode(sourceFile, isSourceFile);
|
|
const emitNode = getOrCreateEmitNode(parseNode);
|
|
emitNode.externalHelpers = true;
|
|
}
|
|
}
|
|
} else {
|
|
const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault);
|
|
if (externalHelpersModuleName) {
|
|
namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName);
|
|
}
|
|
}
|
|
if (namedBindings) {
|
|
const externalHelpersImportDeclaration = nodeFactory.createImportDeclaration(
|
|
void 0,
|
|
nodeFactory.createImportClause(false, void 0, namedBindings),
|
|
nodeFactory.createStringLiteral(externalHelpersModuleNameText),
|
|
void 0
|
|
);
|
|
addEmitFlags(externalHelpersImportDeclaration, 134217728 /* NeverApplyImportHelper */);
|
|
return externalHelpersImportDeclaration;
|
|
}
|
|
}
|
|
}
|
|
function getOrCreateExternalHelpersModuleNameIfNeeded(factory2, node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) {
|
|
if (compilerOptions.importHelpers && isEffectiveExternalModule(node, compilerOptions)) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(node);
|
|
if (externalHelpersModuleName) {
|
|
return externalHelpersModuleName;
|
|
}
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
let create = (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || node.impliedNodeFormat === 1 /* CommonJS */);
|
|
if (!create) {
|
|
const helpers = getEmitHelpers(node);
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
create = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (create) {
|
|
const parseNode = getOriginalNode(node, isSourceFile);
|
|
const emitNode = getOrCreateEmitNode(parseNode);
|
|
return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory2.createUniqueName(externalHelpersModuleNameText));
|
|
}
|
|
}
|
|
}
|
|
function getLocalNameForExternalImport(factory2, node, sourceFile) {
|
|
const namespaceDeclaration = getNamespaceDeclarationNode(node);
|
|
if (namespaceDeclaration && !isDefaultImport(node) && !isExportNamespaceAsDefaultDeclaration(node)) {
|
|
const name = namespaceDeclaration.name;
|
|
return isGeneratedIdentifier(name) ? name : factory2.createIdentifier(getSourceTextOfNodeFromSourceFile(sourceFile, name) || idText(name));
|
|
}
|
|
if (node.kind === 269 /* ImportDeclaration */ && node.importClause) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
if (node.kind === 275 /* ExportDeclaration */ && node.moduleSpecifier) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExternalModuleNameLiteral(factory2, importNode, sourceFile, host, resolver, compilerOptions) {
|
|
const moduleName = getExternalModuleName(importNode);
|
|
if (moduleName && isStringLiteral(moduleName)) {
|
|
return tryGetModuleNameFromDeclaration(importNode, host, factory2, resolver, compilerOptions) || tryRenameExternalModule(factory2, moduleName, sourceFile) || factory2.cloneNode(moduleName);
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryRenameExternalModule(factory2, moduleName, sourceFile) {
|
|
const rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
|
|
return rename ? factory2.createStringLiteral(rename) : void 0;
|
|
}
|
|
function tryGetModuleNameFromFile(factory2, file, host, options) {
|
|
if (!file) {
|
|
return void 0;
|
|
}
|
|
if (file.moduleName) {
|
|
return factory2.createStringLiteral(file.moduleName);
|
|
}
|
|
if (!file.isDeclarationFile && outFile(options)) {
|
|
return factory2.createStringLiteral(getExternalModuleNameFromPath(host, file.fileName));
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetModuleNameFromDeclaration(declaration, host, factory2, resolver, compilerOptions) {
|
|
return tryGetModuleNameFromFile(factory2, resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
|
|
}
|
|
function getInitializerOfBindingOrAssignmentElement(bindingElement) {
|
|
if (isDeclarationBindingElement(bindingElement)) {
|
|
return bindingElement.initializer;
|
|
}
|
|
if (isPropertyAssignment(bindingElement)) {
|
|
const initializer = bindingElement.initializer;
|
|
return isAssignmentExpression(initializer, true) ? initializer.right : void 0;
|
|
}
|
|
if (isShorthandPropertyAssignment(bindingElement)) {
|
|
return bindingElement.objectAssignmentInitializer;
|
|
}
|
|
if (isAssignmentExpression(bindingElement, true)) {
|
|
return bindingElement.right;
|
|
}
|
|
if (isSpreadElement(bindingElement)) {
|
|
return getInitializerOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
}
|
|
function getTargetOfBindingOrAssignmentElement(bindingElement) {
|
|
if (isDeclarationBindingElement(bindingElement)) {
|
|
return bindingElement.name;
|
|
}
|
|
if (isObjectLiteralElementLike(bindingElement)) {
|
|
switch (bindingElement.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return bindingElement.name;
|
|
case 301 /* SpreadAssignment */:
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (isAssignmentExpression(bindingElement, true)) {
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.left);
|
|
}
|
|
if (isSpreadElement(bindingElement)) {
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
return bindingElement;
|
|
}
|
|
function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
return bindingElement.dotDotDotToken;
|
|
case 227 /* SpreadElement */:
|
|
case 301 /* SpreadAssignment */:
|
|
return bindingElement;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPropertyNameOfBindingOrAssignmentElement(bindingElement) {
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement);
|
|
Debug.assert(!!propertyName || isSpreadAssignment(bindingElement), "Invalid property name for binding element.");
|
|
return propertyName;
|
|
}
|
|
function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 205 /* BindingElement */:
|
|
if (bindingElement.propertyName) {
|
|
const propertyName = bindingElement.propertyName;
|
|
if (isPrivateIdentifier(propertyName)) {
|
|
return Debug.failBadSyntaxKind(propertyName);
|
|
}
|
|
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) ? propertyName.expression : propertyName;
|
|
}
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
if (bindingElement.name) {
|
|
const propertyName = bindingElement.name;
|
|
if (isPrivateIdentifier(propertyName)) {
|
|
return Debug.failBadSyntaxKind(propertyName);
|
|
}
|
|
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) ? propertyName.expression : propertyName;
|
|
}
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
if (bindingElement.name && isPrivateIdentifier(bindingElement.name)) {
|
|
return Debug.failBadSyntaxKind(bindingElement.name);
|
|
}
|
|
return bindingElement.name;
|
|
}
|
|
const target = getTargetOfBindingOrAssignmentElement(bindingElement);
|
|
if (target && isPropertyName(target)) {
|
|
return target;
|
|
}
|
|
}
|
|
function isStringOrNumericLiteral(node) {
|
|
const kind = node.kind;
|
|
return kind === 10 /* StringLiteral */ || kind === 8 /* NumericLiteral */;
|
|
}
|
|
function getElementsOfBindingOrAssignmentPattern(name) {
|
|
switch (name.kind) {
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return name.elements;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return name.properties;
|
|
}
|
|
}
|
|
function getJSDocTypeAliasName(fullName) {
|
|
if (fullName) {
|
|
let rightNode = fullName;
|
|
while (true) {
|
|
if (isIdentifier(rightNode) || !rightNode.body) {
|
|
return isIdentifier(rightNode) ? rightNode : rightNode.name;
|
|
}
|
|
rightNode = rightNode.body;
|
|
}
|
|
}
|
|
}
|
|
function canHaveIllegalTypeParameters(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function canHaveIllegalDecorators(node) {
|
|
const kind = node.kind;
|
|
return kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 259 /* FunctionDeclaration */ || kind === 173 /* Constructor */ || kind === 178 /* IndexSignature */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 279 /* MissingDeclaration */ || kind === 240 /* VariableStatement */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 267 /* NamespaceExportDeclaration */ || kind === 275 /* ExportDeclaration */ || kind === 274 /* ExportAssignment */;
|
|
}
|
|
function canHaveIllegalModifiers(node) {
|
|
const kind = node.kind;
|
|
return kind === 172 /* ClassStaticBlockDeclaration */ || kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 181 /* FunctionType */ || kind === 279 /* MissingDeclaration */ || kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
var isTypeNodeOrTypeParameterDeclaration = or(isTypeNode, isTypeParameterDeclaration);
|
|
var isQuestionOrExclamationToken = or(isQuestionToken, isExclamationToken);
|
|
var isIdentifierOrThisTypeNode = or(isIdentifier, isThisTypeNode);
|
|
var isReadonlyKeywordOrPlusOrMinusToken = or(isReadonlyKeyword, isPlusToken, isMinusToken);
|
|
var isQuestionOrPlusOrMinusToken = or(isQuestionToken, isPlusToken, isMinusToken);
|
|
var isModuleName = or(isIdentifier, isStringLiteral);
|
|
function isExponentiationOperator(kind) {
|
|
return kind === 42 /* AsteriskAsteriskToken */;
|
|
}
|
|
function isMultiplicativeOperator(kind) {
|
|
return kind === 41 /* AsteriskToken */ || kind === 43 /* SlashToken */ || kind === 44 /* PercentToken */;
|
|
}
|
|
function isMultiplicativeOperatorOrHigher(kind) {
|
|
return isExponentiationOperator(kind) || isMultiplicativeOperator(kind);
|
|
}
|
|
function isAdditiveOperator(kind) {
|
|
return kind === 39 /* PlusToken */ || kind === 40 /* MinusToken */;
|
|
}
|
|
function isAdditiveOperatorOrHigher(kind) {
|
|
return isAdditiveOperator(kind) || isMultiplicativeOperatorOrHigher(kind);
|
|
}
|
|
function isShiftOperator(kind) {
|
|
return kind === 47 /* LessThanLessThanToken */ || kind === 48 /* GreaterThanGreaterThanToken */ || kind === 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
}
|
|
function isShiftOperatorOrHigher(kind) {
|
|
return isShiftOperator(kind) || isAdditiveOperatorOrHigher(kind);
|
|
}
|
|
function isRelationalOperator(kind) {
|
|
return kind === 29 /* LessThanToken */ || kind === 32 /* LessThanEqualsToken */ || kind === 31 /* GreaterThanToken */ || kind === 33 /* GreaterThanEqualsToken */ || kind === 102 /* InstanceOfKeyword */ || kind === 101 /* InKeyword */;
|
|
}
|
|
function isRelationalOperatorOrHigher(kind) {
|
|
return isRelationalOperator(kind) || isShiftOperatorOrHigher(kind);
|
|
}
|
|
function isEqualityOperator(kind) {
|
|
return kind === 34 /* EqualsEqualsToken */ || kind === 36 /* EqualsEqualsEqualsToken */ || kind === 35 /* ExclamationEqualsToken */ || kind === 37 /* ExclamationEqualsEqualsToken */;
|
|
}
|
|
function isEqualityOperatorOrHigher(kind) {
|
|
return isEqualityOperator(kind) || isRelationalOperatorOrHigher(kind);
|
|
}
|
|
function isBitwiseOperator(kind) {
|
|
return kind === 50 /* AmpersandToken */ || kind === 51 /* BarToken */ || kind === 52 /* CaretToken */;
|
|
}
|
|
function isBitwiseOperatorOrHigher(kind) {
|
|
return isBitwiseOperator(kind) || isEqualityOperatorOrHigher(kind);
|
|
}
|
|
function isLogicalOperator2(kind) {
|
|
return kind === 55 /* AmpersandAmpersandToken */ || kind === 56 /* BarBarToken */;
|
|
}
|
|
function isLogicalOperatorOrHigher(kind) {
|
|
return isLogicalOperator2(kind) || isBitwiseOperatorOrHigher(kind);
|
|
}
|
|
function isAssignmentOperatorOrHigher(kind) {
|
|
return kind === 60 /* QuestionQuestionToken */ || isLogicalOperatorOrHigher(kind) || isAssignmentOperator(kind);
|
|
}
|
|
function isBinaryOperator(kind) {
|
|
return isAssignmentOperatorOrHigher(kind) || kind === 27 /* CommaToken */;
|
|
}
|
|
function isBinaryOperatorToken(node) {
|
|
return isBinaryOperator(node.kind);
|
|
}
|
|
var BinaryExpressionState;
|
|
((BinaryExpressionState2) => {
|
|
function enter(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, outerState) {
|
|
const prevUserState = stackIndex > 0 ? userStateStack[stackIndex - 1] : void 0;
|
|
Debug.assertEqual(stateStack[stackIndex], enter);
|
|
userStateStack[stackIndex] = machine.onEnter(nodeStack[stackIndex], prevUserState, outerState);
|
|
stateStack[stackIndex] = nextState(machine, enter);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.enter = enter;
|
|
function left(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], left);
|
|
Debug.assertIsDefined(machine.onLeft);
|
|
stateStack[stackIndex] = nextState(machine, left);
|
|
const 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;
|
|
}
|
|
BinaryExpressionState2.left = left;
|
|
function operator(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], operator);
|
|
Debug.assertIsDefined(machine.onOperator);
|
|
stateStack[stackIndex] = nextState(machine, operator);
|
|
machine.onOperator(nodeStack[stackIndex].operatorToken, userStateStack[stackIndex], nodeStack[stackIndex]);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.operator = operator;
|
|
function right(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], right);
|
|
Debug.assertIsDefined(machine.onRight);
|
|
stateStack[stackIndex] = nextState(machine, right);
|
|
const 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;
|
|
}
|
|
BinaryExpressionState2.right = right;
|
|
function exit(machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], exit);
|
|
stateStack[stackIndex] = nextState(machine, exit);
|
|
const result = machine.onExit(nodeStack[stackIndex], userStateStack[stackIndex]);
|
|
if (stackIndex > 0) {
|
|
stackIndex--;
|
|
if (machine.foldState) {
|
|
const side = stateStack[stackIndex] === exit ? "right" : "left";
|
|
userStateStack[stackIndex] = machine.foldState(userStateStack[stackIndex], result, side);
|
|
}
|
|
} else {
|
|
resultHolder.value = result;
|
|
}
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.exit = exit;
|
|
function done(_machine, stackIndex, stateStack, _nodeStack, _userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], done);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.done = done;
|
|
function nextState(machine, currentState) {
|
|
switch (currentState) {
|
|
case enter:
|
|
if (machine.onLeft)
|
|
return left;
|
|
case left:
|
|
if (machine.onOperator)
|
|
return operator;
|
|
case operator:
|
|
if (machine.onRight)
|
|
return right;
|
|
case right:
|
|
return exit;
|
|
case exit:
|
|
return done;
|
|
case done:
|
|
return done;
|
|
default:
|
|
Debug.fail("Invalid state");
|
|
}
|
|
}
|
|
BinaryExpressionState2.nextState = nextState;
|
|
function pushStack(stackIndex, stateStack, nodeStack, userStateStack, node) {
|
|
stackIndex++;
|
|
stateStack[stackIndex] = enter;
|
|
nodeStack[stackIndex] = node;
|
|
userStateStack[stackIndex] = void 0;
|
|
return stackIndex;
|
|
}
|
|
function checkCircularity(stackIndex, nodeStack, node) {
|
|
if (Debug.shouldAssert(2 /* Aggressive */)) {
|
|
while (stackIndex >= 0) {
|
|
Debug.assert(nodeStack[stackIndex] !== node, "Circular traversal detected.");
|
|
stackIndex--;
|
|
}
|
|
}
|
|
}
|
|
})(BinaryExpressionState || (BinaryExpressionState = {}));
|
|
var BinaryExpressionStateMachine = class {
|
|
constructor(onEnter, onLeft, onOperator, onRight, onExit, foldState) {
|
|
this.onEnter = onEnter;
|
|
this.onLeft = onLeft;
|
|
this.onOperator = onOperator;
|
|
this.onRight = onRight;
|
|
this.onExit = onExit;
|
|
this.foldState = foldState;
|
|
}
|
|
};
|
|
function createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState) {
|
|
const machine = new BinaryExpressionStateMachine(onEnter, onLeft, onOperator, onRight, onExit, foldState);
|
|
return trampoline;
|
|
function trampoline(node, outerState) {
|
|
const resultHolder = { value: void 0 };
|
|
const stateStack = [BinaryExpressionState.enter];
|
|
const nodeStack = [node];
|
|
const userStateStack = [void 0];
|
|
let stackIndex = 0;
|
|
while (stateStack[stackIndex] !== BinaryExpressionState.done) {
|
|
stackIndex = stateStack[stackIndex](machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, outerState);
|
|
}
|
|
Debug.assertEqual(stackIndex, 0);
|
|
return resultHolder.value;
|
|
}
|
|
}
|
|
function elideNodes(factory2, nodes) {
|
|
if (nodes === void 0)
|
|
return void 0;
|
|
if (nodes.length === 0)
|
|
return nodes;
|
|
return setTextRange(factory2.createNodeArray([], nodes.hasTrailingComma), nodes);
|
|
}
|
|
function getNodeForGeneratedName(name) {
|
|
if (name.autoGenerateFlags & 4 /* Node */) {
|
|
const autoGenerateId = name.autoGenerateId;
|
|
let node = name;
|
|
let original = node.original;
|
|
while (original) {
|
|
node = original;
|
|
if (isMemberName(node) && !!(node.autoGenerateFlags & 4 /* Node */) && node.autoGenerateId !== autoGenerateId) {
|
|
break;
|
|
}
|
|
original = node.original;
|
|
}
|
|
return node;
|
|
}
|
|
return name;
|
|
}
|
|
function formatGeneratedNamePart(part, generateName) {
|
|
return typeof part === "object" ? formatGeneratedName(false, part.prefix, part.node, part.suffix, generateName) : typeof part === "string" ? part.length > 0 && part.charCodeAt(0) === 35 /* hash */ ? part.slice(1) : part : "";
|
|
}
|
|
function formatIdentifier(name, generateName) {
|
|
return typeof name === "string" ? name : formatIdentifierWorker(name, Debug.checkDefined(generateName));
|
|
}
|
|
function formatIdentifierWorker(node, generateName) {
|
|
return isGeneratedPrivateIdentifier(node) ? generateName(node).slice(1) : isGeneratedIdentifier(node) ? generateName(node) : isPrivateIdentifier(node) ? node.escapedText.slice(1) : idText(node);
|
|
}
|
|
function formatGeneratedName(privateName, prefix, baseName, suffix, generateName) {
|
|
prefix = formatGeneratedNamePart(prefix, generateName);
|
|
suffix = formatGeneratedNamePart(suffix, generateName);
|
|
baseName = formatIdentifier(baseName, generateName);
|
|
return `${privateName ? "#" : ""}${prefix}${baseName}${suffix}`;
|
|
}
|
|
function createAccessorPropertyBackingField(factory2, node, modifiers, initializer) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
modifiers,
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage"),
|
|
void 0,
|
|
void 0,
|
|
initializer
|
|
);
|
|
}
|
|
function createAccessorPropertyGetRedirector(factory2, node, modifiers, name) {
|
|
return factory2.createGetAccessorDeclaration(
|
|
modifiers,
|
|
name,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock([
|
|
factory2.createReturnStatement(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage")
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function createAccessorPropertySetRedirector(factory2, node, modifiers, name) {
|
|
return factory2.createSetAccessorDeclaration(
|
|
modifiers,
|
|
name,
|
|
[factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"value"
|
|
)],
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage")
|
|
),
|
|
factory2.createIdentifier("value")
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
|
|
// src/compiler/factory/utilitiesPublic.ts
|
|
function setTextRange(range, location) {
|
|
return location ? setTextRangePosEnd(range, location.pos, location.end) : range;
|
|
}
|
|
function canHaveModifiers(node) {
|
|
const kind = node.kind;
|
|
return kind === 165 /* TypeParameter */ || kind === 166 /* Parameter */ || kind === 168 /* PropertySignature */ || kind === 169 /* PropertyDeclaration */ || kind === 170 /* MethodSignature */ || kind === 171 /* MethodDeclaration */ || kind === 173 /* Constructor */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 178 /* IndexSignature */ || kind === 182 /* ConstructorType */ || kind === 215 /* FunctionExpression */ || kind === 216 /* ArrowFunction */ || kind === 228 /* ClassExpression */ || kind === 240 /* VariableStatement */ || kind === 259 /* FunctionDeclaration */ || kind === 260 /* ClassDeclaration */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 274 /* ExportAssignment */ || kind === 275 /* ExportDeclaration */;
|
|
}
|
|
function canHaveDecorators(node) {
|
|
const kind = node.kind;
|
|
return kind === 166 /* Parameter */ || kind === 169 /* PropertyDeclaration */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 228 /* ClassExpression */ || kind === 260 /* ClassDeclaration */;
|
|
}
|
|
|
|
// src/compiler/parser.ts
|
|
var NodeConstructor;
|
|
var TokenConstructor;
|
|
var IdentifierConstructor;
|
|
var PrivateIdentifierConstructor;
|
|
var SourceFileConstructor;
|
|
var parseBaseNodeFactory = {
|
|
createBaseSourceFileNode: (kind) => new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, -1, -1),
|
|
createBaseIdentifierNode: (kind) => new (IdentifierConstructor || (IdentifierConstructor = objectAllocator.getIdentifierConstructor()))(kind, -1, -1),
|
|
createBasePrivateIdentifierNode: (kind) => new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1),
|
|
createBaseTokenNode: (kind) => new (TokenConstructor || (TokenConstructor = objectAllocator.getTokenConstructor()))(kind, -1, -1),
|
|
createBaseNode: (kind) => new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, -1, -1)
|
|
};
|
|
var parseNodeFactory = createNodeFactory(1 /* NoParenthesizerRules */, parseBaseNodeFactory);
|
|
function visitNode2(cbNode, node) {
|
|
return node && cbNode(node);
|
|
}
|
|
function visitNodes(cbNode, cbNodes, nodes) {
|
|
if (nodes) {
|
|
if (cbNodes) {
|
|
return cbNodes(nodes);
|
|
}
|
|
for (const node of nodes) {
|
|
const result = cbNode(node);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isJSDocLikeText(text, start) {
|
|
return text.charCodeAt(start + 1) === 42 /* asterisk */ && text.charCodeAt(start + 2) === 42 /* asterisk */ && text.charCodeAt(start + 3) !== 47 /* slash */;
|
|
}
|
|
function isFileProbablyExternalModule(sourceFile) {
|
|
return forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) || getImportMetaIfNecessary(sourceFile);
|
|
}
|
|
function isAnExternalModuleIndicatorNode(node) {
|
|
return canHaveModifiers(node) && hasModifierOfKind(node, 93 /* ExportKeyword */) || isImportEqualsDeclaration(node) && isExternalModuleReference(node.moduleReference) || isImportDeclaration(node) || isExportAssignment(node) || isExportDeclaration(node) ? node : void 0;
|
|
}
|
|
function getImportMetaIfNecessary(sourceFile) {
|
|
return sourceFile.flags & 4194304 /* PossiblyContainsImportMeta */ ? walkTreeForImportMeta(sourceFile) : void 0;
|
|
}
|
|
function walkTreeForImportMeta(node) {
|
|
return isImportMeta2(node) ? node : forEachChild(node, walkTreeForImportMeta);
|
|
}
|
|
function hasModifierOfKind(node, kind) {
|
|
return some(node.modifiers, (m) => m.kind === kind);
|
|
}
|
|
function isImportMeta2(node) {
|
|
return isMetaProperty(node) && node.keywordToken === 100 /* ImportKeyword */ && node.name.escapedText === "meta";
|
|
}
|
|
var forEachChildTable = {
|
|
[163 /* QualifiedName */]: function forEachChildInQualifiedName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.right);
|
|
},
|
|
[165 /* TypeParameter */]: function forEachChildInTypeParameter(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.constraint) || visitNode2(cbNode, node.default) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[300 /* ShorthandPropertyAssignment */]: function forEachChildInShorthandPropertyAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.equalsToken) || visitNode2(cbNode, node.objectAssignmentInitializer);
|
|
},
|
|
[301 /* SpreadAssignment */]: function forEachChildInSpreadAssignment(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[166 /* Parameter */]: function forEachChildInParameter(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[169 /* PropertyDeclaration */]: function forEachChildInPropertyDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[168 /* PropertySignature */]: function forEachChildInPropertySignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[299 /* PropertyAssignment */]: function forEachChildInPropertyAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[257 /* VariableDeclaration */]: function forEachChildInVariableDeclaration(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[205 /* BindingElement */]: function forEachChildInBindingElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.propertyName) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[178 /* 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) || visitNode2(cbNode, node.type);
|
|
},
|
|
[182 /* ConstructorType */]: function forEachChildInConstructorType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[181 /* FunctionType */]: function forEachChildInFunctionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[176 /* CallSignature */]: forEachChildInCallOrConstructSignature,
|
|
[177 /* ConstructSignature */]: forEachChildInCallOrConstructSignature,
|
|
[171 /* MethodDeclaration */]: function forEachChildInMethodDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[170 /* MethodSignature */]: function forEachChildInMethodSignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[173 /* Constructor */]: function forEachChildInConstructor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[174 /* GetAccessor */]: function forEachChildInGetAccessor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[175 /* SetAccessor */]: function forEachChildInSetAccessor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[259 /* FunctionDeclaration */]: function forEachChildInFunctionDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[215 /* FunctionExpression */]: function forEachChildInFunctionExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[216 /* ArrowFunction */]: function forEachChildInArrowFunction(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.equalsGreaterThanToken) || visitNode2(cbNode, node.body);
|
|
},
|
|
[172 /* ClassStaticBlockDeclaration */]: function forEachChildInClassStaticBlockDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.body);
|
|
},
|
|
[180 /* TypeReference */]: function forEachChildInTypeReference(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.typeName) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[179 /* TypePredicate */]: function forEachChildInTypePredicate(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.assertsModifier) || visitNode2(cbNode, node.parameterName) || visitNode2(cbNode, node.type);
|
|
},
|
|
[183 /* TypeQuery */]: function forEachChildInTypeQuery(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.exprName) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[184 /* TypeLiteral */]: function forEachChildInTypeLiteral(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[185 /* ArrayType */]: function forEachChildInArrayType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.elementType);
|
|
},
|
|
[186 /* TupleType */]: function forEachChildInTupleType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[189 /* UnionType */]: forEachChildInUnionOrIntersectionType,
|
|
[190 /* IntersectionType */]: forEachChildInUnionOrIntersectionType,
|
|
[191 /* ConditionalType */]: function forEachChildInConditionalType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.checkType) || visitNode2(cbNode, node.extendsType) || visitNode2(cbNode, node.trueType) || visitNode2(cbNode, node.falseType);
|
|
},
|
|
[192 /* InferType */]: function forEachChildInInferType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.typeParameter);
|
|
},
|
|
[202 /* ImportType */]: function forEachChildInImportType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.argument) || visitNode2(cbNode, node.assertions) || visitNode2(cbNode, node.qualifier) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[298 /* ImportTypeAssertionContainer */]: function forEachChildInImportTypeAssertionContainer(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[193 /* ParenthesizedType */]: forEachChildInParenthesizedTypeOrTypeOperator,
|
|
[195 /* TypeOperator */]: forEachChildInParenthesizedTypeOrTypeOperator,
|
|
[196 /* IndexedAccessType */]: function forEachChildInIndexedAccessType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.objectType) || visitNode2(cbNode, node.indexType);
|
|
},
|
|
[197 /* MappedType */]: function forEachChildInMappedType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.readonlyToken) || visitNode2(cbNode, node.typeParameter) || visitNode2(cbNode, node.nameType) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[198 /* LiteralType */]: function forEachChildInLiteralType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.literal);
|
|
},
|
|
[199 /* NamedTupleMember */]: function forEachChildInNamedTupleMember(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type);
|
|
},
|
|
[203 /* ObjectBindingPattern */]: forEachChildInObjectOrArrayBindingPattern,
|
|
[204 /* ArrayBindingPattern */]: forEachChildInObjectOrArrayBindingPattern,
|
|
[206 /* ArrayLiteralExpression */]: function forEachChildInArrayLiteralExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[207 /* ObjectLiteralExpression */]: function forEachChildInObjectLiteralExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.properties);
|
|
},
|
|
[208 /* PropertyAccessExpression */]: function forEachChildInPropertyAccessExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.questionDotToken) || visitNode2(cbNode, node.name);
|
|
},
|
|
[209 /* ElementAccessExpression */]: function forEachChildInElementAccessExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.questionDotToken) || visitNode2(cbNode, node.argumentExpression);
|
|
},
|
|
[210 /* CallExpression */]: forEachChildInCallOrNewExpression,
|
|
[211 /* NewExpression */]: forEachChildInCallOrNewExpression,
|
|
[212 /* TaggedTemplateExpression */]: function forEachChildInTaggedTemplateExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tag) || visitNode2(cbNode, node.questionDotToken) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode2(cbNode, node.template);
|
|
},
|
|
[213 /* TypeAssertionExpression */]: function forEachChildInTypeAssertionExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[214 /* ParenthesizedExpression */]: function forEachChildInParenthesizedExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[217 /* DeleteExpression */]: function forEachChildInDeleteExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[218 /* TypeOfExpression */]: function forEachChildInTypeOfExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[219 /* VoidExpression */]: function forEachChildInVoidExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[221 /* PrefixUnaryExpression */]: function forEachChildInPrefixUnaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.operand);
|
|
},
|
|
[226 /* YieldExpression */]: function forEachChildInYieldExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[220 /* AwaitExpression */]: function forEachChildInAwaitExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[222 /* PostfixUnaryExpression */]: function forEachChildInPostfixUnaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.operand);
|
|
},
|
|
[223 /* BinaryExpression */]: function forEachChildInBinaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.operatorToken) || visitNode2(cbNode, node.right);
|
|
},
|
|
[231 /* AsExpression */]: function forEachChildInAsExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.type);
|
|
},
|
|
[232 /* NonNullExpression */]: function forEachChildInNonNullExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[235 /* SatisfiesExpression */]: function forEachChildInSatisfiesExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.type);
|
|
},
|
|
[233 /* MetaProperty */]: function forEachChildInMetaProperty(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[224 /* ConditionalExpression */]: function forEachChildInConditionalExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.condition) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.whenTrue) || visitNode2(cbNode, node.colonToken) || visitNode2(cbNode, node.whenFalse);
|
|
},
|
|
[227 /* SpreadElement */]: function forEachChildInSpreadElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[238 /* Block */]: forEachChildInBlock,
|
|
[265 /* ModuleBlock */]: forEachChildInBlock,
|
|
[308 /* SourceFile */]: function forEachChildInSourceFile(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.statements) || visitNode2(cbNode, node.endOfFileToken);
|
|
},
|
|
[240 /* VariableStatement */]: function forEachChildInVariableStatement(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.declarationList);
|
|
},
|
|
[258 /* VariableDeclarationList */]: function forEachChildInVariableDeclarationList(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.declarations);
|
|
},
|
|
[241 /* ExpressionStatement */]: function forEachChildInExpressionStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[242 /* IfStatement */]: function forEachChildInIfStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.thenStatement) || visitNode2(cbNode, node.elseStatement);
|
|
},
|
|
[243 /* DoStatement */]: function forEachChildInDoStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.statement) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[244 /* WhileStatement */]: function forEachChildInWhileStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[245 /* ForStatement */]: function forEachChildInForStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.condition) || visitNode2(cbNode, node.incrementor) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[246 /* ForInStatement */]: function forEachChildInForInStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[247 /* ForOfStatement */]: function forEachChildInForOfStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.awaitModifier) || visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[248 /* ContinueStatement */]: forEachChildInContinueOrBreakStatement,
|
|
[249 /* BreakStatement */]: forEachChildInContinueOrBreakStatement,
|
|
[250 /* ReturnStatement */]: function forEachChildInReturnStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[251 /* WithStatement */]: function forEachChildInWithStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[252 /* SwitchStatement */]: function forEachChildInSwitchStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.caseBlock);
|
|
},
|
|
[266 /* CaseBlock */]: function forEachChildInCaseBlock(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.clauses);
|
|
},
|
|
[292 /* CaseClause */]: function forEachChildInCaseClause(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.statements);
|
|
},
|
|
[293 /* DefaultClause */]: function forEachChildInDefaultClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.statements);
|
|
},
|
|
[253 /* LabeledStatement */]: function forEachChildInLabeledStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.label) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[254 /* ThrowStatement */]: function forEachChildInThrowStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[255 /* TryStatement */]: function forEachChildInTryStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.tryBlock) || visitNode2(cbNode, node.catchClause) || visitNode2(cbNode, node.finallyBlock);
|
|
},
|
|
[295 /* CatchClause */]: function forEachChildInCatchClause(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.variableDeclaration) || visitNode2(cbNode, node.block);
|
|
},
|
|
[167 /* Decorator */]: function forEachChildInDecorator(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[260 /* ClassDeclaration */]: forEachChildInClassDeclarationOrExpression,
|
|
[228 /* ClassExpression */]: forEachChildInClassDeclarationOrExpression,
|
|
[261 /* InterfaceDeclaration */]: function forEachChildInInterfaceDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.heritageClauses) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[262 /* TypeAliasDeclaration */]: function forEachChildInTypeAliasDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[263 /* EnumDeclaration */]: function forEachChildInEnumDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[302 /* EnumMember */]: function forEachChildInEnumMember(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[264 /* ModuleDeclaration */]: function forEachChildInModuleDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.body);
|
|
},
|
|
[268 /* ImportEqualsDeclaration */]: function forEachChildInImportEqualsDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.moduleReference);
|
|
},
|
|
[269 /* ImportDeclaration */]: function forEachChildInImportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.importClause) || visitNode2(cbNode, node.moduleSpecifier) || visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[270 /* ImportClause */]: function forEachChildInImportClause(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.namedBindings);
|
|
},
|
|
[296 /* AssertClause */]: function forEachChildInAssertClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[297 /* AssertEntry */]: function forEachChildInAssertEntry(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.value);
|
|
},
|
|
[267 /* NamespaceExportDeclaration */]: function forEachChildInNamespaceExportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNode2(cbNode, node.name);
|
|
},
|
|
[271 /* NamespaceImport */]: function forEachChildInNamespaceImport(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[277 /* NamespaceExport */]: function forEachChildInNamespaceExport(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[272 /* NamedImports */]: forEachChildInNamedImportsOrExports,
|
|
[276 /* NamedExports */]: forEachChildInNamedImportsOrExports,
|
|
[275 /* ExportDeclaration */]: function forEachChildInExportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.exportClause) || visitNode2(cbNode, node.moduleSpecifier) || visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[273 /* ImportSpecifier */]: forEachChildInImportOrExportSpecifier,
|
|
[278 /* ExportSpecifier */]: forEachChildInImportOrExportSpecifier,
|
|
[274 /* ExportAssignment */]: function forEachChildInExportAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[225 /* TemplateExpression */]: function forEachChildInTemplateExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
|
|
},
|
|
[236 /* TemplateSpan */]: function forEachChildInTemplateSpan(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.literal);
|
|
},
|
|
[200 /* TemplateLiteralType */]: function forEachChildInTemplateLiteralType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
|
|
},
|
|
[201 /* TemplateLiteralTypeSpan */]: function forEachChildInTemplateLiteralTypeSpan(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type) || visitNode2(cbNode, node.literal);
|
|
},
|
|
[164 /* ComputedPropertyName */]: function forEachChildInComputedPropertyName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[294 /* HeritageClause */]: function forEachChildInHeritageClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.types);
|
|
},
|
|
[230 /* ExpressionWithTypeArguments */]: function forEachChildInExpressionWithTypeArguments(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[280 /* ExternalModuleReference */]: function forEachChildInExternalModuleReference(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[279 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers);
|
|
},
|
|
[354 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[281 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.openingElement) || visitNodes(cbNode, cbNodes, node.children) || visitNode2(cbNode, node.closingElement);
|
|
},
|
|
[285 /* JsxFragment */]: function forEachChildInJsxFragment(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.openingFragment) || visitNodes(cbNode, cbNodes, node.children) || visitNode2(cbNode, node.closingFragment);
|
|
},
|
|
[282 /* JsxSelfClosingElement */]: forEachChildInJsxOpeningOrSelfClosingElement,
|
|
[283 /* JsxOpeningElement */]: forEachChildInJsxOpeningOrSelfClosingElement,
|
|
[289 /* JsxAttributes */]: function forEachChildInJsxAttributes(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.properties);
|
|
},
|
|
[288 /* JsxAttribute */]: function forEachChildInJsxAttribute(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[290 /* JsxSpreadAttribute */]: function forEachChildInJsxSpreadAttribute(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[291 /* JsxExpression */]: function forEachChildInJsxExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[284 /* JsxClosingElement */]: function forEachChildInJsxClosingElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.tagName);
|
|
},
|
|
[187 /* OptionalType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[188 /* RestType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[312 /* JSDocTypeExpression */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[318 /* JSDocNonNullableType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[317 /* JSDocNullableType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[319 /* JSDocOptionalType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[321 /* JSDocVariadicType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[320 /* JSDocFunctionType */]: function forEachChildInJSDocFunctionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[323 /* JSDoc */]: function forEachChildInJSDoc(node, cbNode, cbNodes) {
|
|
return (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)) || visitNodes(cbNode, cbNodes, node.tags);
|
|
},
|
|
[349 /* JSDocSeeTag */]: function forEachChildInJSDocSeeTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.name) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[313 /* JSDocNameReference */]: function forEachChildInJSDocNameReference(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[314 /* JSDocMemberName */]: function forEachChildInJSDocMemberName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.right);
|
|
},
|
|
[343 /* JSDocParameterTag */]: forEachChildInJSDocParameterOrPropertyTag,
|
|
[350 /* JSDocPropertyTag */]: forEachChildInJSDocParameterOrPropertyTag,
|
|
[333 /* JSDocAuthorTag */]: function forEachChildInJSDocAuthorTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[332 /* JSDocImplementsTag */]: function forEachChildInJSDocImplementsTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.class) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[331 /* JSDocAugmentsTag */]: function forEachChildInJSDocAugmentsTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.class) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[347 /* JSDocTemplateTag */]: function forEachChildInJSDocTemplateTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.constraint) || visitNodes(cbNode, cbNodes, node.typeParameters) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[348 /* JSDocTypedefTag */]: function forEachChildInJSDocTypedefTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (node.typeExpression && node.typeExpression.kind === 312 /* JSDocTypeExpression */ ? visitNode2(cbNode, node.typeExpression) || visitNode2(cbNode, node.fullName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)) : visitNode2(cbNode, node.fullName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)));
|
|
},
|
|
[341 /* JSDocCallbackTag */]: function forEachChildInJSDocCallbackTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.fullName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[344 /* JSDocReturnTag */]: forEachChildInJSDocReturnTag,
|
|
[346 /* JSDocTypeTag */]: forEachChildInJSDocReturnTag,
|
|
[345 /* JSDocThisTag */]: forEachChildInJSDocReturnTag,
|
|
[342 /* JSDocEnumTag */]: forEachChildInJSDocReturnTag,
|
|
[326 /* JSDocSignature */]: function forEachChildInJSDocSignature(node, cbNode, _cbNodes) {
|
|
return forEach(node.typeParameters, cbNode) || forEach(node.parameters, cbNode) || visitNode2(cbNode, node.type);
|
|
},
|
|
[327 /* JSDocLink */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[328 /* JSDocLinkCode */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[329 /* JSDocLinkPlain */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[325 /* JSDocTypeLiteral */]: function forEachChildInJSDocTypeLiteral(node, cbNode, _cbNodes) {
|
|
return forEach(node.jsDocPropertyTags, cbNode);
|
|
},
|
|
[330 /* JSDocTag */]: forEachChildInJSDocTag,
|
|
[335 /* JSDocClassTag */]: forEachChildInJSDocTag,
|
|
[336 /* JSDocPublicTag */]: forEachChildInJSDocTag,
|
|
[337 /* JSDocPrivateTag */]: forEachChildInJSDocTag,
|
|
[338 /* JSDocProtectedTag */]: forEachChildInJSDocTag,
|
|
[339 /* JSDocReadonlyTag */]: forEachChildInJSDocTag,
|
|
[334 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag,
|
|
[340 /* JSDocOverrideTag */]: forEachChildInJSDocTag,
|
|
[353 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
|
|
};
|
|
function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.types);
|
|
}
|
|
function forEachChildInParenthesizedTypeOrTypeOperator(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInObjectOrArrayBindingPattern(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
}
|
|
function forEachChildInCallOrNewExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(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 visitNode2(cbNode, node.label);
|
|
}
|
|
function forEachChildInClassDeclarationOrExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(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 visitNode2(cbNode, node.propertyName) || visitNode2(cbNode, node.name);
|
|
}
|
|
function forEachChildInJsxOpeningOrSelfClosingElement(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode2(cbNode, node.attributes);
|
|
}
|
|
function forEachChildInOptionalRestOrJSDocParameterModifier(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInJSDocParameterOrPropertyTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (node.isNameFirst ? visitNode2(cbNode, node.name) || visitNode2(cbNode, node.typeExpression) : visitNode2(cbNode, node.typeExpression) || visitNode2(cbNode, node.name)) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInJSDocReturnTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInJSDocLinkCodeOrPlain(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
}
|
|
function forEachChildInJSDocTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInPartiallyEmittedExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
}
|
|
function forEachChild(node, cbNode, cbNodes) {
|
|
if (node === void 0 || node.kind <= 162 /* LastToken */) {
|
|
return;
|
|
}
|
|
const fn = forEachChildTable[node.kind];
|
|
return fn === void 0 ? void 0 : fn(node, cbNode, cbNodes);
|
|
}
|
|
function forEachChildRecursively(rootNode, cbNode, cbNodes) {
|
|
const queue = gatherPossibleChildren(rootNode);
|
|
const parents = [];
|
|
while (parents.length < queue.length) {
|
|
parents.push(rootNode);
|
|
}
|
|
while (queue.length !== 0) {
|
|
const current = queue.pop();
|
|
const parent = parents.pop();
|
|
if (isArray(current)) {
|
|
if (cbNodes) {
|
|
const res = cbNodes(current, parent);
|
|
if (res) {
|
|
if (res === "skip")
|
|
continue;
|
|
return res;
|
|
}
|
|
}
|
|
for (let i = current.length - 1; i >= 0; --i) {
|
|
queue.push(current[i]);
|
|
parents.push(parent);
|
|
}
|
|
} else {
|
|
const res = cbNode(current, parent);
|
|
if (res) {
|
|
if (res === "skip")
|
|
continue;
|
|
return res;
|
|
}
|
|
if (current.kind >= 163 /* FirstNode */) {
|
|
for (const child of gatherPossibleChildren(current)) {
|
|
queue.push(child);
|
|
parents.push(current);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function gatherPossibleChildren(node) {
|
|
const children = [];
|
|
forEachChild(node, addWorkItem, addWorkItem);
|
|
return children;
|
|
function addWorkItem(n) {
|
|
children.unshift(n);
|
|
}
|
|
}
|
|
function setExternalModuleIndicator(sourceFile) {
|
|
sourceFile.externalModuleIndicator = isFileProbablyExternalModule(sourceFile);
|
|
}
|
|
function createSourceFile(fileName, sourceText, languageVersionOrOptions, setParentNodes = false, scriptKind) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Parse, "createSourceFile", { path: fileName }, true);
|
|
mark("beforeParse");
|
|
let result;
|
|
perfLogger.logStartParseSourceFile(fileName);
|
|
const {
|
|
languageVersion,
|
|
setExternalModuleIndicator: overrideSetExternalModuleIndicator,
|
|
impliedNodeFormat: format
|
|
} = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions };
|
|
if (languageVersion === 100 /* JSON */) {
|
|
result = Parser.parseSourceFile(fileName, sourceText, languageVersion, void 0, setParentNodes, 6 /* JSON */, noop);
|
|
} else {
|
|
const setIndicator = format === void 0 ? overrideSetExternalModuleIndicator : (file) => {
|
|
file.impliedNodeFormat = format;
|
|
return (overrideSetExternalModuleIndicator || setExternalModuleIndicator)(file);
|
|
};
|
|
result = Parser.parseSourceFile(fileName, sourceText, languageVersion, void 0, setParentNodes, scriptKind, setIndicator);
|
|
}
|
|
perfLogger.logStopParseSourceFile();
|
|
mark("afterParse");
|
|
measure("Parse", "beforeParse", "afterParse");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function parseIsolatedEntityName(text, languageVersion) {
|
|
return Parser.parseIsolatedEntityName(text, languageVersion);
|
|
}
|
|
function parseJsonText(fileName, sourceText) {
|
|
return Parser.parseJsonText(fileName, sourceText);
|
|
}
|
|
function isExternalModule(file) {
|
|
return file.externalModuleIndicator !== void 0;
|
|
}
|
|
var Parser;
|
|
((Parser2) => {
|
|
const scanner = createScanner(99 /* Latest */, true);
|
|
const disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
|
|
let NodeConstructor2;
|
|
let TokenConstructor2;
|
|
let IdentifierConstructor2;
|
|
let PrivateIdentifierConstructor2;
|
|
let SourceFileConstructor2;
|
|
function countNode(node) {
|
|
nodeCount++;
|
|
return node;
|
|
}
|
|
const baseNodeFactory = {
|
|
createBaseSourceFileNode: (kind) => countNode(new SourceFileConstructor2(kind, 0, 0)),
|
|
createBaseIdentifierNode: (kind) => countNode(new IdentifierConstructor2(kind, 0, 0)),
|
|
createBasePrivateIdentifierNode: (kind) => countNode(new PrivateIdentifierConstructor2(kind, 0, 0)),
|
|
createBaseTokenNode: (kind) => countNode(new TokenConstructor2(kind, 0, 0)),
|
|
createBaseNode: (kind) => countNode(new NodeConstructor2(kind, 0, 0))
|
|
};
|
|
const factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
|
|
let fileName;
|
|
let sourceFlags;
|
|
let sourceText;
|
|
let languageVersion;
|
|
let scriptKind;
|
|
let languageVariant;
|
|
let parseDiagnostics;
|
|
let jsDocDiagnostics;
|
|
let syntaxCursor;
|
|
let currentToken;
|
|
let nodeCount;
|
|
let identifiers;
|
|
let privateIdentifiers;
|
|
let identifierCount;
|
|
let parsingContext;
|
|
let notParenthesizedArrow;
|
|
let contextFlags;
|
|
let topLevel = true;
|
|
let parseErrorBeforeNextFinishedNode = false;
|
|
function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride) {
|
|
var _a2;
|
|
scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
|
|
if (scriptKind2 === 6 /* JSON */) {
|
|
const result2 = parseJsonText2(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes);
|
|
convertToObjectWorker(result2, (_a2 = result2.statements[0]) == null ? void 0 : _a2.expression, result2.parseDiagnostics, false, void 0, void 0);
|
|
result2.referencedFiles = emptyArray;
|
|
result2.typeReferenceDirectives = emptyArray;
|
|
result2.libReferenceDirectives = emptyArray;
|
|
result2.amdDependencies = emptyArray;
|
|
result2.hasNoDefaultLib = false;
|
|
result2.pragmas = emptyMap;
|
|
return result2;
|
|
}
|
|
initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, scriptKind2);
|
|
const result = parseSourceFileWorker(languageVersion2, setParentNodes, scriptKind2, setExternalModuleIndicatorOverride || setExternalModuleIndicator);
|
|
clearState();
|
|
return result;
|
|
}
|
|
Parser2.parseSourceFile = parseSourceFile;
|
|
function parseIsolatedEntityName2(content, languageVersion2) {
|
|
initializeState("", content, languageVersion2, void 0, 1 /* JS */);
|
|
nextToken();
|
|
const entityName = parseEntityName(true);
|
|
const isInvalid = token() === 1 /* EndOfFileToken */ && !parseDiagnostics.length;
|
|
clearState();
|
|
return isInvalid ? entityName : void 0;
|
|
}
|
|
Parser2.parseIsolatedEntityName = parseIsolatedEntityName2;
|
|
function parseJsonText2(fileName2, sourceText2, languageVersion2 = 2 /* ES2015 */, syntaxCursor2, setParentNodes = false) {
|
|
initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, 6 /* JSON */);
|
|
sourceFlags = contextFlags;
|
|
nextToken();
|
|
const pos = getNodePos();
|
|
let statements, endOfFileToken;
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
statements = createNodeArray([], pos, pos);
|
|
endOfFileToken = parseTokenNode();
|
|
} else {
|
|
let expressions;
|
|
while (token() !== 1 /* EndOfFileToken */) {
|
|
let expression2;
|
|
switch (token()) {
|
|
case 22 /* OpenBracketToken */:
|
|
expression2 = parseArrayLiteralExpression();
|
|
break;
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
expression2 = parseTokenNode();
|
|
break;
|
|
case 40 /* MinusToken */:
|
|
if (lookAhead(() => nextToken() === 8 /* NumericLiteral */ && nextToken() !== 58 /* ColonToken */)) {
|
|
expression2 = parsePrefixUnaryExpression();
|
|
} else {
|
|
expression2 = parseObjectLiteralExpression();
|
|
}
|
|
break;
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
if (lookAhead(() => nextToken() !== 58 /* ColonToken */)) {
|
|
expression2 = parseLiteralNode();
|
|
break;
|
|
}
|
|
default:
|
|
expression2 = parseObjectLiteralExpression();
|
|
break;
|
|
}
|
|
if (expressions && isArray(expressions)) {
|
|
expressions.push(expression2);
|
|
} else if (expressions) {
|
|
expressions = [expressions, expression2];
|
|
} else {
|
|
expressions = expression2;
|
|
if (token() !== 1 /* EndOfFileToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Unexpected_token);
|
|
}
|
|
}
|
|
}
|
|
const expression = isArray(expressions) ? finishNode(factory2.createArrayLiteralExpression(expressions), pos) : Debug.checkDefined(expressions);
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
finishNode(statement, pos);
|
|
statements = createNodeArray([statement], pos);
|
|
endOfFileToken = parseExpectedToken(1 /* EndOfFileToken */, Diagnostics.Unexpected_token);
|
|
}
|
|
const sourceFile = createSourceFile2(fileName2, 2 /* ES2015 */, 6 /* JSON */, false, statements, endOfFileToken, sourceFlags, noop);
|
|
if (setParentNodes) {
|
|
fixupParentReferences(sourceFile);
|
|
}
|
|
sourceFile.nodeCount = nodeCount;
|
|
sourceFile.identifierCount = identifierCount;
|
|
sourceFile.identifiers = identifiers;
|
|
sourceFile.parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
const result = sourceFile;
|
|
clearState();
|
|
return result;
|
|
}
|
|
Parser2.parseJsonText = parseJsonText2;
|
|
function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) {
|
|
NodeConstructor2 = objectAllocator.getNodeConstructor();
|
|
TokenConstructor2 = objectAllocator.getTokenConstructor();
|
|
IdentifierConstructor2 = objectAllocator.getIdentifierConstructor();
|
|
PrivateIdentifierConstructor2 = objectAllocator.getPrivateIdentifierConstructor();
|
|
SourceFileConstructor2 = objectAllocator.getSourceFileConstructor();
|
|
fileName = normalizePath(_fileName);
|
|
sourceText = _sourceText;
|
|
languageVersion = _languageVersion;
|
|
syntaxCursor = _syntaxCursor;
|
|
scriptKind = _scriptKind;
|
|
languageVariant = getLanguageVariant(_scriptKind);
|
|
parseDiagnostics = [];
|
|
parsingContext = 0;
|
|
identifiers = /* @__PURE__ */ new Map();
|
|
privateIdentifiers = /* @__PURE__ */ new Map();
|
|
identifierCount = 0;
|
|
nodeCount = 0;
|
|
sourceFlags = 0;
|
|
topLevel = true;
|
|
switch (scriptKind) {
|
|
case 1 /* JS */:
|
|
case 2 /* JSX */:
|
|
contextFlags = 262144 /* JavaScriptFile */;
|
|
break;
|
|
case 6 /* JSON */:
|
|
contextFlags = 262144 /* JavaScriptFile */ | 67108864 /* JsonFile */;
|
|
break;
|
|
default:
|
|
contextFlags = 0 /* None */;
|
|
break;
|
|
}
|
|
parseErrorBeforeNextFinishedNode = false;
|
|
scanner.setText(sourceText);
|
|
scanner.setOnError(scanError);
|
|
scanner.setScriptTarget(languageVersion);
|
|
scanner.setLanguageVariant(languageVariant);
|
|
}
|
|
function clearState() {
|
|
scanner.clearCommentDirectives();
|
|
scanner.setText("");
|
|
scanner.setOnError(void 0);
|
|
sourceText = void 0;
|
|
languageVersion = void 0;
|
|
syntaxCursor = void 0;
|
|
scriptKind = void 0;
|
|
languageVariant = void 0;
|
|
sourceFlags = 0;
|
|
parseDiagnostics = void 0;
|
|
jsDocDiagnostics = void 0;
|
|
parsingContext = 0;
|
|
identifiers = void 0;
|
|
notParenthesizedArrow = void 0;
|
|
topLevel = true;
|
|
}
|
|
function parseSourceFileWorker(languageVersion2, setParentNodes, scriptKind2, setExternalModuleIndicator2) {
|
|
const isDeclarationFile = isDeclarationFileName(fileName);
|
|
if (isDeclarationFile) {
|
|
contextFlags |= 16777216 /* Ambient */;
|
|
}
|
|
sourceFlags = contextFlags;
|
|
nextToken();
|
|
const statements = parseList(ParsingContext.SourceElements, parseStatement);
|
|
Debug.assert(token() === 1 /* EndOfFileToken */);
|
|
const endOfFileToken = addJSDocComment(parseTokenNode());
|
|
const sourceFile = createSourceFile2(fileName, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator2);
|
|
processCommentPragmas(sourceFile, sourceText);
|
|
processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
|
|
sourceFile.commentDirectives = scanner.getCommentDirectives();
|
|
sourceFile.nodeCount = nodeCount;
|
|
sourceFile.identifierCount = identifierCount;
|
|
sourceFile.identifiers = identifiers;
|
|
sourceFile.parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
if (setParentNodes) {
|
|
fixupParentReferences(sourceFile);
|
|
}
|
|
return sourceFile;
|
|
function reportPragmaDiagnostic(pos, end, diagnostic) {
|
|
parseDiagnostics.push(createDetachedDiagnostic(fileName, pos, end, diagnostic));
|
|
}
|
|
}
|
|
function withJSDoc(node, hasJSDoc) {
|
|
return hasJSDoc ? addJSDocComment(node) : node;
|
|
}
|
|
let hasDeprecatedTag = false;
|
|
function addJSDocComment(node) {
|
|
Debug.assert(!node.jsDoc);
|
|
const jsDoc = mapDefined(getJSDocCommentRanges(node, sourceText), (comment) => JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos));
|
|
if (jsDoc.length)
|
|
node.jsDoc = jsDoc;
|
|
if (hasDeprecatedTag) {
|
|
hasDeprecatedTag = false;
|
|
node.flags |= 268435456 /* Deprecated */;
|
|
}
|
|
return node;
|
|
}
|
|
function reparseTopLevelAwait(sourceFile) {
|
|
const savedSyntaxCursor = syntaxCursor;
|
|
const baseSyntaxCursor = IncrementalParser.createSyntaxCursor(sourceFile);
|
|
syntaxCursor = { currentNode: currentNode2 };
|
|
const statements = [];
|
|
const savedParseDiagnostics = parseDiagnostics;
|
|
parseDiagnostics = [];
|
|
let pos = 0;
|
|
let start = findNextStatementWithAwait(sourceFile.statements, 0);
|
|
while (start !== -1) {
|
|
const prevStatement = sourceFile.statements[pos];
|
|
const nextStatement = sourceFile.statements[start];
|
|
addRange(statements, sourceFile.statements, pos, start);
|
|
pos = findNextStatementWithoutAwait(sourceFile.statements, start);
|
|
const diagnosticStart = findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= prevStatement.pos);
|
|
const diagnosticEnd = diagnosticStart >= 0 ? findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= nextStatement.pos, diagnosticStart) : -1;
|
|
if (diagnosticStart >= 0) {
|
|
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart, diagnosticEnd >= 0 ? diagnosticEnd : void 0);
|
|
}
|
|
speculationHelper(() => {
|
|
const savedContextFlags = contextFlags;
|
|
contextFlags |= 32768 /* AwaitContext */;
|
|
scanner.setTextPos(nextStatement.pos);
|
|
nextToken();
|
|
while (token() !== 1 /* EndOfFileToken */) {
|
|
const startPos = scanner.getStartPos();
|
|
const statement = parseListElement(ParsingContext.SourceElements, parseStatement);
|
|
statements.push(statement);
|
|
if (startPos === scanner.getStartPos()) {
|
|
nextToken();
|
|
}
|
|
if (pos >= 0) {
|
|
const nonAwaitStatement = sourceFile.statements[pos];
|
|
if (statement.end === nonAwaitStatement.pos) {
|
|
break;
|
|
}
|
|
if (statement.end > nonAwaitStatement.pos) {
|
|
pos = findNextStatementWithoutAwait(sourceFile.statements, pos + 1);
|
|
}
|
|
}
|
|
}
|
|
contextFlags = savedContextFlags;
|
|
}, 2 /* Reparse */);
|
|
start = pos >= 0 ? findNextStatementWithAwait(sourceFile.statements, pos) : -1;
|
|
}
|
|
if (pos >= 0) {
|
|
const prevStatement = sourceFile.statements[pos];
|
|
addRange(statements, sourceFile.statements, pos);
|
|
const diagnosticStart = findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= prevStatement.pos);
|
|
if (diagnosticStart >= 0) {
|
|
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart);
|
|
}
|
|
}
|
|
syntaxCursor = savedSyntaxCursor;
|
|
return factory2.updateSourceFile(sourceFile, setTextRange(factory2.createNodeArray(statements), sourceFile.statements));
|
|
function containsPossibleTopLevelAwait(node) {
|
|
return !(node.flags & 32768 /* AwaitContext */) && !!(node.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */);
|
|
}
|
|
function findNextStatementWithAwait(statements2, start2) {
|
|
for (let i = start2; i < statements2.length; i++) {
|
|
if (containsPossibleTopLevelAwait(statements2[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function findNextStatementWithoutAwait(statements2, start2) {
|
|
for (let i = start2; i < statements2.length; i++) {
|
|
if (!containsPossibleTopLevelAwait(statements2[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function currentNode2(position) {
|
|
const node = baseSyntaxCursor.currentNode(position);
|
|
if (topLevel && node && containsPossibleTopLevelAwait(node)) {
|
|
node.intersectsChange = true;
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function fixupParentReferences(rootNode) {
|
|
setParentRecursive(rootNode, true);
|
|
}
|
|
Parser2.fixupParentReferences = fixupParentReferences;
|
|
function createSourceFile2(fileName2, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, flags, setExternalModuleIndicator2) {
|
|
let sourceFile = factory2.createSourceFile(statements, endOfFileToken, flags);
|
|
setTextRangePosWidth(sourceFile, 0, sourceText.length);
|
|
setFields(sourceFile);
|
|
if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */) {
|
|
sourceFile = reparseTopLevelAwait(sourceFile);
|
|
setFields(sourceFile);
|
|
}
|
|
return sourceFile;
|
|
function setFields(sourceFile2) {
|
|
sourceFile2.text = sourceText;
|
|
sourceFile2.bindDiagnostics = [];
|
|
sourceFile2.bindSuggestionDiagnostics = void 0;
|
|
sourceFile2.languageVersion = languageVersion2;
|
|
sourceFile2.fileName = fileName2;
|
|
sourceFile2.languageVariant = getLanguageVariant(scriptKind2);
|
|
sourceFile2.isDeclarationFile = isDeclarationFile;
|
|
sourceFile2.scriptKind = scriptKind2;
|
|
setExternalModuleIndicator2(sourceFile2);
|
|
sourceFile2.setExternalModuleIndicator = setExternalModuleIndicator2;
|
|
}
|
|
}
|
|
function setContextFlag(val, flag) {
|
|
if (val) {
|
|
contextFlags |= flag;
|
|
} else {
|
|
contextFlags &= ~flag;
|
|
}
|
|
}
|
|
function setDisallowInContext(val) {
|
|
setContextFlag(val, 4096 /* DisallowInContext */);
|
|
}
|
|
function setYieldContext(val) {
|
|
setContextFlag(val, 8192 /* YieldContext */);
|
|
}
|
|
function setDecoratorContext(val) {
|
|
setContextFlag(val, 16384 /* DecoratorContext */);
|
|
}
|
|
function setAwaitContext(val) {
|
|
setContextFlag(val, 32768 /* AwaitContext */);
|
|
}
|
|
function doOutsideOfContext(context, func) {
|
|
const contextFlagsToClear = context & contextFlags;
|
|
if (contextFlagsToClear) {
|
|
setContextFlag(false, contextFlagsToClear);
|
|
const result = func();
|
|
setContextFlag(true, contextFlagsToClear);
|
|
return result;
|
|
}
|
|
return func();
|
|
}
|
|
function doInsideOfContext(context, func) {
|
|
const contextFlagsToSet = context & ~contextFlags;
|
|
if (contextFlagsToSet) {
|
|
setContextFlag(true, contextFlagsToSet);
|
|
const result = func();
|
|
setContextFlag(false, contextFlagsToSet);
|
|
return result;
|
|
}
|
|
return func();
|
|
}
|
|
function allowInAnd(func) {
|
|
return doOutsideOfContext(4096 /* DisallowInContext */, func);
|
|
}
|
|
function disallowInAnd(func) {
|
|
return doInsideOfContext(4096 /* DisallowInContext */, func);
|
|
}
|
|
function allowConditionalTypesAnd(func) {
|
|
return doOutsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
|
|
}
|
|
function disallowConditionalTypesAnd(func) {
|
|
return doInsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
|
|
}
|
|
function doInYieldContext(func) {
|
|
return doInsideOfContext(8192 /* YieldContext */, func);
|
|
}
|
|
function doInDecoratorContext(func) {
|
|
return doInsideOfContext(16384 /* DecoratorContext */, func);
|
|
}
|
|
function doInAwaitContext(func) {
|
|
return doInsideOfContext(32768 /* AwaitContext */, func);
|
|
}
|
|
function doOutsideOfAwaitContext(func) {
|
|
return doOutsideOfContext(32768 /* AwaitContext */, func);
|
|
}
|
|
function doInYieldAndAwaitContext(func) {
|
|
return doInsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */, func);
|
|
}
|
|
function doOutsideOfYieldAndAwaitContext(func) {
|
|
return doOutsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */, func);
|
|
}
|
|
function inContext(flags) {
|
|
return (contextFlags & flags) !== 0;
|
|
}
|
|
function inYieldContext() {
|
|
return inContext(8192 /* YieldContext */);
|
|
}
|
|
function inDisallowInContext() {
|
|
return inContext(4096 /* DisallowInContext */);
|
|
}
|
|
function inDisallowConditionalTypesContext() {
|
|
return inContext(65536 /* DisallowConditionalTypesContext */);
|
|
}
|
|
function inDecoratorContext() {
|
|
return inContext(16384 /* DecoratorContext */);
|
|
}
|
|
function inAwaitContext() {
|
|
return inContext(32768 /* AwaitContext */);
|
|
}
|
|
function parseErrorAtCurrentToken(message, arg0) {
|
|
return parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
|
|
}
|
|
function parseErrorAtPosition(start, length2, message, arg0) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
let result;
|
|
if (!lastError || start !== lastError.start) {
|
|
result = createDetachedDiagnostic(fileName, start, length2, message, arg0);
|
|
parseDiagnostics.push(result);
|
|
}
|
|
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, length2) {
|
|
parseErrorAtPosition(scanner.getTextPos(), length2, message);
|
|
}
|
|
function getNodePos() {
|
|
return scanner.getStartPos();
|
|
}
|
|
function hasPrecedingJSDocComment() {
|
|
return scanner.hasPrecedingJSDocComment();
|
|
}
|
|
function token() {
|
|
return currentToken;
|
|
}
|
|
function nextTokenWithoutCheck() {
|
|
return currentToken = scanner.scan();
|
|
}
|
|
function nextTokenAnd(func) {
|
|
nextToken();
|
|
return func();
|
|
}
|
|
function nextToken() {
|
|
if (isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) {
|
|
parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), 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) {
|
|
const saveToken = currentToken;
|
|
const saveParseDiagnosticsLength = parseDiagnostics.length;
|
|
const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
|
|
const saveContextFlags = contextFlags;
|
|
const result = speculationKind !== 0 /* TryParse */ ? scanner.lookAhead(callback) : scanner.tryScan(callback);
|
|
Debug.assert(saveContextFlags === contextFlags);
|
|
if (!result || speculationKind !== 0 /* TryParse */) {
|
|
currentToken = saveToken;
|
|
if (speculationKind !== 2 /* Reparse */) {
|
|
parseDiagnostics.length = saveParseDiagnosticsLength;
|
|
}
|
|
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
|
|
}
|
|
return result;
|
|
}
|
|
function lookAhead(callback) {
|
|
return speculationHelper(callback, 1 /* Lookahead */);
|
|
}
|
|
function tryParse(callback) {
|
|
return speculationHelper(callback, 0 /* TryParse */);
|
|
}
|
|
function isBindingIdentifier() {
|
|
if (token() === 79 /* Identifier */) {
|
|
return true;
|
|
}
|
|
return token() > 116 /* LastReservedWord */;
|
|
}
|
|
function isIdentifier2() {
|
|
if (token() === 79 /* Identifier */) {
|
|
return true;
|
|
}
|
|
if (token() === 125 /* YieldKeyword */ && inYieldContext()) {
|
|
return false;
|
|
}
|
|
if (token() === 133 /* AwaitKeyword */ && inAwaitContext()) {
|
|
return false;
|
|
}
|
|
return token() > 116 /* LastReservedWord */;
|
|
}
|
|
function parseExpected(kind, diagnosticMessage, shouldAdvance = true) {
|
|
if (token() === kind) {
|
|
if (shouldAdvance) {
|
|
nextToken();
|
|
}
|
|
return true;
|
|
}
|
|
if (diagnosticMessage) {
|
|
parseErrorAtCurrentToken(diagnosticMessage);
|
|
} else {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
|
|
}
|
|
return false;
|
|
}
|
|
const viableKeywordSuggestions = Object.keys(textToKeywordObj).filter((keyword) => keyword.length > 2);
|
|
function parseErrorForMissingSemicolonAfter(node) {
|
|
var _a2;
|
|
if (isTaggedTemplateExpression(node)) {
|
|
parseErrorAt(skipTrivia(sourceText, node.template.pos), node.template.end, Diagnostics.Module_declaration_names_may_only_use_or_quoted_strings);
|
|
return;
|
|
}
|
|
const expressionText = isIdentifier(node) ? idText(node) : void 0;
|
|
if (!expressionText || !isIdentifierText(expressionText, languageVersion)) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
return;
|
|
}
|
|
const pos = skipTrivia(sourceText, node.pos);
|
|
switch (expressionText) {
|
|
case "const":
|
|
case "let":
|
|
case "var":
|
|
parseErrorAt(pos, node.end, Diagnostics.Variable_declaration_not_allowed_at_this_location);
|
|
return;
|
|
case "declare":
|
|
return;
|
|
case "interface":
|
|
parseErrorForInvalidName(Diagnostics.Interface_name_cannot_be_0, Diagnostics.Interface_must_be_given_a_name, 18 /* OpenBraceToken */);
|
|
return;
|
|
case "is":
|
|
parseErrorAt(pos, scanner.getTextPos(), Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
|
|
return;
|
|
case "module":
|
|
case "namespace":
|
|
parseErrorForInvalidName(Diagnostics.Namespace_name_cannot_be_0, Diagnostics.Namespace_must_be_given_a_name, 18 /* OpenBraceToken */);
|
|
return;
|
|
case "type":
|
|
parseErrorForInvalidName(Diagnostics.Type_alias_name_cannot_be_0, Diagnostics.Type_alias_must_be_given_a_name, 63 /* EqualsToken */);
|
|
return;
|
|
}
|
|
const suggestion = (_a2 = getSpellingSuggestion(expressionText, viableKeywordSuggestions, (n) => n)) != null ? _a2 : getSpaceSuggestion(expressionText);
|
|
if (suggestion) {
|
|
parseErrorAt(pos, node.end, Diagnostics.Unknown_keyword_or_identifier_Did_you_mean_0, suggestion);
|
|
return;
|
|
}
|
|
if (token() === 0 /* Unknown */) {
|
|
return;
|
|
}
|
|
parseErrorAt(pos, node.end, Diagnostics.Unexpected_keyword_or_identifier);
|
|
}
|
|
function parseErrorForInvalidName(nameDiagnostic, blankDiagnostic, tokenIfBlankName) {
|
|
if (token() === tokenIfBlankName) {
|
|
parseErrorAtCurrentToken(blankDiagnostic);
|
|
} else {
|
|
parseErrorAtCurrentToken(nameDiagnostic, scanner.getTokenValue());
|
|
}
|
|
}
|
|
function getSpaceSuggestion(expressionText) {
|
|
for (const keyword of viableKeywordSuggestions) {
|
|
if (expressionText.length > keyword.length + 2 && startsWith(expressionText, keyword)) {
|
|
return `${keyword} ${expressionText.slice(keyword.length)}`;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseSemicolonAfterPropertyName(name, type, initializer) {
|
|
if (token() === 59 /* AtToken */ && !scanner.hasPrecedingLineBreak()) {
|
|
parseErrorAtCurrentToken(Diagnostics.Decorators_must_precede_the_name_and_all_keywords_of_property_declarations);
|
|
return;
|
|
}
|
|
if (token() === 20 /* OpenParenToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Cannot_start_a_function_call_in_a_type_annotation);
|
|
nextToken();
|
|
return;
|
|
}
|
|
if (type && !canParseSemicolon()) {
|
|
if (initializer) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
} else {
|
|
parseErrorAtCurrentToken(Diagnostics.Expected_for_property_initializer);
|
|
}
|
|
return;
|
|
}
|
|
if (tryParseSemicolon()) {
|
|
return;
|
|
}
|
|
if (initializer) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
return;
|
|
}
|
|
parseErrorForMissingSemicolonAfter(name);
|
|
}
|
|
function parseExpectedJSDoc(kind) {
|
|
if (token() === kind) {
|
|
nextTokenJSDoc();
|
|
return true;
|
|
}
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
|
|
return false;
|
|
}
|
|
function parseExpectedMatchingBrackets(openKind, closeKind, openParsed, openPosition) {
|
|
if (token() === closeKind) {
|
|
nextToken();
|
|
return;
|
|
}
|
|
const lastError = parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(closeKind));
|
|
if (!openParsed) {
|
|
return;
|
|
}
|
|
if (lastError) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openPosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, tokenToString(openKind), tokenToString(closeKind))
|
|
);
|
|
}
|
|
}
|
|
function parseOptional(t) {
|
|
if (token() === t) {
|
|
nextToken();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseOptionalToken(t) {
|
|
if (token() === t) {
|
|
return parseTokenNode();
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseOptionalTokenJSDoc(t) {
|
|
if (token() === t) {
|
|
return parseTokenNodeJSDoc();
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseExpectedToken(t, diagnosticMessage, arg0) {
|
|
return parseOptionalToken(t) || createMissingNode(t, false, diagnosticMessage || Diagnostics._0_expected, arg0 || tokenToString(t));
|
|
}
|
|
function parseExpectedTokenJSDoc(t) {
|
|
return parseOptionalTokenJSDoc(t) || createMissingNode(t, false, Diagnostics._0_expected, tokenToString(t));
|
|
}
|
|
function parseTokenNode() {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
nextToken();
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function parseTokenNodeJSDoc() {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
nextTokenJSDoc();
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function canParseSemicolon() {
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
return true;
|
|
}
|
|
return token() === 19 /* CloseBraceToken */ || token() === 1 /* EndOfFileToken */ || scanner.hasPrecedingLineBreak();
|
|
}
|
|
function tryParseSemicolon() {
|
|
if (!canParseSemicolon()) {
|
|
return false;
|
|
}
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
nextToken();
|
|
}
|
|
return true;
|
|
}
|
|
function parseSemicolon() {
|
|
return tryParseSemicolon() || parseExpected(26 /* SemicolonToken */);
|
|
}
|
|
function createNodeArray(elements, pos, end, hasTrailingComma) {
|
|
const array = factory2.createNodeArray(elements, hasTrailingComma);
|
|
setTextRangePosEnd(array, pos, end != null ? end : scanner.getStartPos());
|
|
return array;
|
|
}
|
|
function finishNode(node, pos, end) {
|
|
setTextRangePosEnd(node, pos, end != null ? end : scanner.getStartPos());
|
|
if (contextFlags) {
|
|
node.flags |= contextFlags;
|
|
}
|
|
if (parseErrorBeforeNextFinishedNode) {
|
|
parseErrorBeforeNextFinishedNode = false;
|
|
node.flags |= 131072 /* ThisNodeHasError */;
|
|
}
|
|
return node;
|
|
}
|
|
function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
|
|
if (reportAtCurrentPosition) {
|
|
parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0);
|
|
} else if (diagnosticMessage) {
|
|
parseErrorAtCurrentToken(diagnosticMessage, arg0);
|
|
}
|
|
const pos = getNodePos();
|
|
const result = kind === 79 /* Identifier */ ? factory2.createIdentifier("", void 0, void 0) : isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, "", "", void 0) : kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral("", void 0) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral("", void 0) : kind === 279 /* MissingDeclaration */ ? factory2.createMissingDeclaration() : factory2.createToken(kind);
|
|
return finishNode(result, pos);
|
|
}
|
|
function internIdentifier(text) {
|
|
let identifier = identifiers.get(text);
|
|
if (identifier === void 0) {
|
|
identifiers.set(text, identifier = text);
|
|
}
|
|
return identifier;
|
|
}
|
|
function createIdentifier(isIdentifier3, diagnosticMessage, privateIdentifierDiagnosticMessage) {
|
|
if (isIdentifier3) {
|
|
identifierCount++;
|
|
const pos = getNodePos();
|
|
const originalKeywordKind = token();
|
|
const text = internIdentifier(scanner.getTokenValue());
|
|
const hasExtendedUnicodeEscape = scanner.hasExtendedUnicodeEscape();
|
|
nextTokenWithoutCheck();
|
|
return finishNode(factory2.createIdentifier(text, void 0, originalKeywordKind, hasExtendedUnicodeEscape), pos);
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
return createIdentifier(true);
|
|
}
|
|
if (token() === 0 /* Unknown */ && scanner.tryScan(() => scanner.reScanInvalidIdentifier() === 79 /* Identifier */)) {
|
|
return createIdentifier(true);
|
|
}
|
|
identifierCount++;
|
|
const reportAtCurrentPosition = token() === 1 /* EndOfFileToken */;
|
|
const isReservedWord = scanner.isReservedWord();
|
|
const msgArg = scanner.getTokenText();
|
|
const defaultMessage = isReservedWord ? Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here : Diagnostics.Identifier_expected;
|
|
return createMissingNode(79 /* Identifier */, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg);
|
|
}
|
|
function parseBindingIdentifier(privateIdentifierDiagnosticMessage) {
|
|
return createIdentifier(isBindingIdentifier(), void 0, privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) {
|
|
return createIdentifier(isIdentifier2(), diagnosticMessage, privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseIdentifierName(diagnosticMessage) {
|
|
return createIdentifier(tokenIsIdentifierOrKeyword(token()), diagnosticMessage);
|
|
}
|
|
function isLiteralPropertyName() {
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */;
|
|
}
|
|
function isAssertionKey2() {
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */;
|
|
}
|
|
function parsePropertyNameWorker(allowComputedPropertyNames) {
|
|
if (token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */) {
|
|
const node = parseLiteralNode();
|
|
node.text = internIdentifier(node.text);
|
|
return node;
|
|
}
|
|
if (allowComputedPropertyNames && token() === 22 /* OpenBracketToken */) {
|
|
return parseComputedPropertyName();
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
return parsePrivateIdentifier();
|
|
}
|
|
return parseIdentifierName();
|
|
}
|
|
function parsePropertyName() {
|
|
return parsePropertyNameWorker(true);
|
|
}
|
|
function parseComputedPropertyName() {
|
|
const pos = getNodePos();
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
return finishNode(factory2.createComputedPropertyName(expression), pos);
|
|
}
|
|
function internPrivateIdentifier(text) {
|
|
let privateIdentifier = privateIdentifiers.get(text);
|
|
if (privateIdentifier === void 0) {
|
|
privateIdentifiers.set(text, privateIdentifier = text);
|
|
}
|
|
return privateIdentifier;
|
|
}
|
|
function parsePrivateIdentifier() {
|
|
const pos = getNodePos();
|
|
const node = factory2.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 /* ConstKeyword */:
|
|
return nextToken() === 92 /* EnumKeyword */;
|
|
case 93 /* ExportKeyword */:
|
|
nextToken();
|
|
if (token() === 88 /* DefaultKeyword */) {
|
|
return lookAhead(nextTokenCanFollowDefaultKeyword);
|
|
}
|
|
if (token() === 154 /* TypeKeyword */) {
|
|
return lookAhead(nextTokenCanFollowExportModifier);
|
|
}
|
|
return canFollowExportModifier();
|
|
case 88 /* DefaultKeyword */:
|
|
return nextTokenCanFollowDefaultKeyword();
|
|
case 127 /* AccessorKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
nextToken();
|
|
return canFollowModifier();
|
|
default:
|
|
return nextTokenIsOnSameLineAndCanFollowModifier();
|
|
}
|
|
}
|
|
function canFollowExportModifier() {
|
|
return token() !== 41 /* AsteriskToken */ && token() !== 128 /* AsKeyword */ && token() !== 18 /* OpenBraceToken */ && canFollowModifier();
|
|
}
|
|
function nextTokenCanFollowExportModifier() {
|
|
nextToken();
|
|
return canFollowExportModifier();
|
|
}
|
|
function parseAnyContextualModifier() {
|
|
return isModifierKind(token()) && tryParse(nextTokenCanFollowModifier);
|
|
}
|
|
function canFollowModifier() {
|
|
return token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */ || token() === 41 /* AsteriskToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
|
|
}
|
|
function nextTokenCanFollowDefaultKeyword() {
|
|
nextToken();
|
|
return token() === 84 /* ClassKeyword */ || token() === 98 /* FunctionKeyword */ || token() === 118 /* InterfaceKeyword */ || token() === 126 /* AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine) || token() === 132 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine);
|
|
}
|
|
function isListElement(parsingContext2, inErrorRecovery) {
|
|
const node = currentNode(parsingContext2);
|
|
if (node) {
|
|
return true;
|
|
}
|
|
switch (parsingContext2) {
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return !(token() === 26 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
|
|
case ParsingContext.SwitchClauses:
|
|
return token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
|
|
case ParsingContext.TypeMembers:
|
|
return lookAhead(isTypeMemberStart);
|
|
case ParsingContext.ClassMembers:
|
|
return lookAhead(isClassMemberStart) || token() === 26 /* SemicolonToken */ && !inErrorRecovery;
|
|
case ParsingContext.EnumMembers:
|
|
return token() === 22 /* OpenBracketToken */ || isLiteralPropertyName();
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
switch (token()) {
|
|
case 22 /* OpenBracketToken */:
|
|
case 41 /* AsteriskToken */:
|
|
case 25 /* DotDotDotToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
default:
|
|
return isLiteralPropertyName();
|
|
}
|
|
case ParsingContext.RestProperties:
|
|
return isLiteralPropertyName();
|
|
case ParsingContext.ObjectBindingElements:
|
|
return token() === 22 /* OpenBracketToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
|
|
case ParsingContext.AssertEntries:
|
|
return isAssertionKey2();
|
|
case ParsingContext.HeritageClauseElement:
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return lookAhead(isValidHeritageClauseObjectLiteral);
|
|
}
|
|
if (!inErrorRecovery) {
|
|
return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
|
|
} else {
|
|
return isIdentifier2() && !isHeritageClauseExtendsOrImplementsKeyword();
|
|
}
|
|
case ParsingContext.VariableDeclarations:
|
|
return isBindingIdentifierOrPrivateIdentifierOrPattern();
|
|
case ParsingContext.ArrayBindingElements:
|
|
return token() === 27 /* CommaToken */ || token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern();
|
|
case ParsingContext.TypeParameters:
|
|
return token() === 101 /* InKeyword */ || isIdentifier2();
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
switch (token()) {
|
|
case 27 /* CommaToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
}
|
|
case ParsingContext.ArgumentExpressions:
|
|
return token() === 25 /* DotDotDotToken */ || isStartOfExpression();
|
|
case ParsingContext.Parameters:
|
|
return isStartOfParameter(false);
|
|
case ParsingContext.JSDocParameters:
|
|
return isStartOfParameter(true);
|
|
case ParsingContext.TypeArguments:
|
|
case ParsingContext.TupleElementTypes:
|
|
return token() === 27 /* CommaToken */ || isStartOfType();
|
|
case ParsingContext.HeritageClauses:
|
|
return isHeritageClause2();
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
return tokenIsIdentifierOrKeyword(token());
|
|
case ParsingContext.JsxAttributes:
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
|
|
case ParsingContext.JsxChildren:
|
|
return true;
|
|
}
|
|
return Debug.fail("Non-exhaustive case in 'isListElement'.");
|
|
}
|
|
function isValidHeritageClauseObjectLiteral() {
|
|
Debug.assert(token() === 18 /* OpenBraceToken */);
|
|
if (nextToken() === 19 /* CloseBraceToken */) {
|
|
const next = nextToken();
|
|
return next === 27 /* CommaToken */ || next === 18 /* OpenBraceToken */ || next === 94 /* ExtendsKeyword */ || next === 117 /* ImplementsKeyword */;
|
|
}
|
|
return true;
|
|
}
|
|
function nextTokenIsIdentifier() {
|
|
nextToken();
|
|
return isIdentifier2();
|
|
}
|
|
function nextTokenIsIdentifierOrKeyword() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token());
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrGreaterThan() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeywordOrGreaterThan(token());
|
|
}
|
|
function isHeritageClauseExtendsOrImplementsKeyword() {
|
|
if (token() === 117 /* ImplementsKeyword */ || token() === 94 /* ExtendsKeyword */) {
|
|
return lookAhead(nextTokenIsStartOfExpression);
|
|
}
|
|
return false;
|
|
}
|
|
function nextTokenIsStartOfExpression() {
|
|
nextToken();
|
|
return isStartOfExpression();
|
|
}
|
|
function nextTokenIsStartOfType() {
|
|
nextToken();
|
|
return isStartOfType();
|
|
}
|
|
function isListTerminator(kind) {
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
return true;
|
|
}
|
|
switch (kind) {
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauses:
|
|
case ParsingContext.TypeMembers:
|
|
case ParsingContext.ClassMembers:
|
|
case ParsingContext.EnumMembers:
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
case ParsingContext.ObjectBindingElements:
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
case ParsingContext.AssertEntries:
|
|
return token() === 19 /* CloseBraceToken */;
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return token() === 19 /* CloseBraceToken */ || token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
|
|
case ParsingContext.HeritageClauseElement:
|
|
return token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
case ParsingContext.VariableDeclarations:
|
|
return isVariableDeclaratorListTerminator();
|
|
case ParsingContext.TypeParameters:
|
|
return token() === 31 /* GreaterThanToken */ || token() === 20 /* OpenParenToken */ || token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
case ParsingContext.ArgumentExpressions:
|
|
return token() === 21 /* CloseParenToken */ || token() === 26 /* SemicolonToken */;
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
case ParsingContext.TupleElementTypes:
|
|
case ParsingContext.ArrayBindingElements:
|
|
return token() === 23 /* CloseBracketToken */;
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
case ParsingContext.RestProperties:
|
|
return token() === 21 /* CloseParenToken */ || token() === 23 /* CloseBracketToken */;
|
|
case ParsingContext.TypeArguments:
|
|
return token() !== 27 /* CommaToken */;
|
|
case ParsingContext.HeritageClauses:
|
|
return token() === 18 /* OpenBraceToken */ || token() === 19 /* CloseBraceToken */;
|
|
case ParsingContext.JsxAttributes:
|
|
return token() === 31 /* GreaterThanToken */ || token() === 43 /* SlashToken */;
|
|
case ParsingContext.JsxChildren:
|
|
return token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsSlash);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isVariableDeclaratorListTerminator() {
|
|
if (canParseSemicolon()) {
|
|
return true;
|
|
}
|
|
if (isInOrOfKeyword(token())) {
|
|
return true;
|
|
}
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isInSomeParsingContext() {
|
|
for (let kind = 0; kind < ParsingContext.Count; kind++) {
|
|
if (parsingContext & 1 << kind) {
|
|
if (isListElement(kind, true) || isListTerminator(kind)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseList(kind, parseElement) {
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << kind;
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
while (!isListTerminator(kind)) {
|
|
if (isListElement(kind, false)) {
|
|
list.push(parseListElement(kind, parseElement));
|
|
continue;
|
|
}
|
|
if (abortParsingListOrMoveToNextToken(kind)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray(list, listPos);
|
|
}
|
|
function parseListElement(parsingContext2, parseElement) {
|
|
const node = currentNode(parsingContext2);
|
|
if (node) {
|
|
return consumeNode(node);
|
|
}
|
|
return parseElement();
|
|
}
|
|
function currentNode(parsingContext2, pos) {
|
|
if (!syntaxCursor || !isReusableParsingContext(parsingContext2) || parseErrorBeforeNextFinishedNode) {
|
|
return void 0;
|
|
}
|
|
const node = syntaxCursor.currentNode(pos != null ? pos : scanner.getStartPos());
|
|
if (nodeIsMissing(node) || node.intersectsChange || containsParseError(node)) {
|
|
return void 0;
|
|
}
|
|
const nodeContextFlags = node.flags & 50720768 /* ContextFlags */;
|
|
if (nodeContextFlags !== contextFlags) {
|
|
return void 0;
|
|
}
|
|
if (!canReuseNode(node, parsingContext2)) {
|
|
return void 0;
|
|
}
|
|
if (node.jsDocCache) {
|
|
node.jsDocCache = void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function consumeNode(node) {
|
|
scanner.setTextPos(node.end);
|
|
nextToken();
|
|
return node;
|
|
}
|
|
function isReusableParsingContext(parsingContext2) {
|
|
switch (parsingContext2) {
|
|
case ParsingContext.ClassMembers:
|
|
case ParsingContext.SwitchClauses:
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
case ParsingContext.EnumMembers:
|
|
case ParsingContext.TypeMembers:
|
|
case ParsingContext.VariableDeclarations:
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function canReuseNode(node, parsingContext2) {
|
|
switch (parsingContext2) {
|
|
case ParsingContext.ClassMembers:
|
|
return isReusableClassMember(node);
|
|
case ParsingContext.SwitchClauses:
|
|
return isReusableSwitchClause(node);
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return isReusableStatement(node);
|
|
case ParsingContext.EnumMembers:
|
|
return isReusableEnumMember(node);
|
|
case ParsingContext.TypeMembers:
|
|
return isReusableTypeMember(node);
|
|
case ParsingContext.VariableDeclarations:
|
|
return isReusableVariableDeclaration(node);
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
return isReusableParameter(node);
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableClassMember(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 178 /* IndexSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 237 /* SemicolonClassElement */:
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
const methodDeclaration = node;
|
|
const nameIsConstructor = methodDeclaration.name.kind === 79 /* Identifier */ && methodDeclaration.name.originalKeywordKind === 135 /* ConstructorKeyword */;
|
|
return !nameIsConstructor;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableSwitchClause(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableStatement(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 238 /* Block */:
|
|
case 242 /* IfStatement */:
|
|
case 241 /* ExpressionStatement */:
|
|
case 254 /* ThrowStatement */:
|
|
case 250 /* ReturnStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 239 /* EmptyStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 253 /* LabeledStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 256 /* DebuggerStatement */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableEnumMember(node) {
|
|
return node.kind === 302 /* EnumMember */;
|
|
}
|
|
function isReusableTypeMember(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 168 /* PropertySignature */:
|
|
case 176 /* CallSignature */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableVariableDeclaration(node) {
|
|
if (node.kind !== 257 /* VariableDeclaration */) {
|
|
return false;
|
|
}
|
|
const variableDeclarator = node;
|
|
return variableDeclarator.initializer === void 0;
|
|
}
|
|
function isReusableParameter(node) {
|
|
if (node.kind !== 166 /* Parameter */) {
|
|
return false;
|
|
}
|
|
const parameter = node;
|
|
return parameter.initializer === void 0;
|
|
}
|
|
function abortParsingListOrMoveToNextToken(kind) {
|
|
parsingContextErrors(kind);
|
|
if (isInSomeParsingContext()) {
|
|
return true;
|
|
}
|
|
nextToken();
|
|
return false;
|
|
}
|
|
function parsingContextErrors(context) {
|
|
switch (context) {
|
|
case ParsingContext.SourceElements:
|
|
return token() === 88 /* DefaultKeyword */ ? parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(93 /* ExportKeyword */)) : parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
|
|
case ParsingContext.BlockStatements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
|
|
case ParsingContext.SwitchClauses:
|
|
return parseErrorAtCurrentToken(Diagnostics.case_or_default_expected);
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
|
|
case ParsingContext.RestProperties:
|
|
case ParsingContext.TypeMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
|
|
case ParsingContext.ClassMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected);
|
|
case ParsingContext.EnumMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Enum_member_expected);
|
|
case ParsingContext.HeritageClauseElement:
|
|
return parseErrorAtCurrentToken(Diagnostics.Expression_expected);
|
|
case ParsingContext.VariableDeclarations:
|
|
return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_variable_declaration_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Variable_declaration_expected);
|
|
case ParsingContext.ObjectBindingElements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_destructuring_pattern_expected);
|
|
case ParsingContext.ArrayBindingElements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Array_element_destructuring_pattern_expected);
|
|
case ParsingContext.ArgumentExpressions:
|
|
return parseErrorAtCurrentToken(Diagnostics.Argument_expression_expected);
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_assignment_expected);
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Expression_or_comma_expected);
|
|
case ParsingContext.JSDocParameters:
|
|
return parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
|
|
case ParsingContext.Parameters:
|
|
return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_parameter_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
|
|
case ParsingContext.TypeParameters:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_parameter_declaration_expected);
|
|
case ParsingContext.TypeArguments:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_argument_expected);
|
|
case ParsingContext.TupleElementTypes:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_expected);
|
|
case ParsingContext.HeritageClauses:
|
|
return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_expected);
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.JsxAttributes:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.JsxChildren:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.AssertEntries:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
|
|
case ParsingContext.Count:
|
|
return Debug.fail("ParsingContext.Count used as a context");
|
|
default:
|
|
Debug.assertNever(context);
|
|
}
|
|
}
|
|
function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << kind;
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
let commaStart = -1;
|
|
while (true) {
|
|
if (isListElement(kind, false)) {
|
|
const startPos = scanner.getStartPos();
|
|
const result = parseListElement(kind, parseElement);
|
|
if (!result) {
|
|
parsingContext = saveParsingContext;
|
|
return void 0;
|
|
}
|
|
list.push(result);
|
|
commaStart = scanner.getTokenPos();
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
continue;
|
|
}
|
|
commaStart = -1;
|
|
if (isListTerminator(kind)) {
|
|
break;
|
|
}
|
|
parseExpected(27 /* CommaToken */, getExpectedCommaDiagnostic(kind));
|
|
if (considerSemicolonAsDelimiter && token() === 26 /* SemicolonToken */ && !scanner.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
}
|
|
if (startPos === scanner.getStartPos()) {
|
|
nextToken();
|
|
}
|
|
continue;
|
|
}
|
|
if (isListTerminator(kind)) {
|
|
break;
|
|
}
|
|
if (abortParsingListOrMoveToNextToken(kind)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray(list, listPos, void 0, commaStart >= 0);
|
|
}
|
|
function getExpectedCommaDiagnostic(kind) {
|
|
return kind === ParsingContext.EnumMembers ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
|
|
}
|
|
function createMissingList() {
|
|
const list = createNodeArray([], getNodePos());
|
|
list.isMissingList = true;
|
|
return list;
|
|
}
|
|
function isMissingList(arr) {
|
|
return !!arr.isMissingList;
|
|
}
|
|
function parseBracketedList(kind, parseElement, open, close) {
|
|
if (parseExpected(open)) {
|
|
const result = parseDelimitedList(kind, parseElement);
|
|
parseExpected(close);
|
|
return result;
|
|
}
|
|
return createMissingList();
|
|
}
|
|
function parseEntityName(allowReservedWords, diagnosticMessage) {
|
|
const pos = getNodePos();
|
|
let entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
|
|
let dotPos = getNodePos();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
entity.jsdocDotPos = dotPos;
|
|
break;
|
|
}
|
|
dotPos = getNodePos();
|
|
entity = finishNode(
|
|
factory2.createQualifiedName(
|
|
entity,
|
|
parseRightSideOfDot(allowReservedWords, false)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
return entity;
|
|
}
|
|
function createQualifiedName(entity, name) {
|
|
return finishNode(factory2.createQualifiedName(entity, name), entity.pos);
|
|
}
|
|
function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) {
|
|
if (scanner.hasPrecedingLineBreak() && tokenIsIdentifierOrKeyword(token())) {
|
|
const matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
|
|
if (matchesPattern) {
|
|
return createMissingNode(79 /* Identifier */, true, Diagnostics.Identifier_expected);
|
|
}
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
const node = parsePrivateIdentifier();
|
|
return allowPrivateIdentifiers ? node : createMissingNode(79 /* Identifier */, true, Diagnostics.Identifier_expected);
|
|
}
|
|
return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
|
|
}
|
|
function parseTemplateSpans(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
const list = [];
|
|
let node;
|
|
do {
|
|
node = parseTemplateSpan(isTaggedTemplate);
|
|
list.push(node);
|
|
} while (node.literal.kind === 16 /* TemplateMiddle */);
|
|
return createNodeArray(list, pos);
|
|
}
|
|
function parseTemplateExpression(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateExpression(
|
|
parseTemplateHead(isTaggedTemplate),
|
|
parseTemplateSpans(isTaggedTemplate)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseTemplateType() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateLiteralType(
|
|
parseTemplateHead(false),
|
|
parseTemplateTypeSpans()
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseTemplateTypeSpans() {
|
|
const pos = getNodePos();
|
|
const list = [];
|
|
let node;
|
|
do {
|
|
node = parseTemplateTypeSpan();
|
|
list.push(node);
|
|
} while (node.literal.kind === 16 /* TemplateMiddle */);
|
|
return createNodeArray(list, pos);
|
|
}
|
|
function parseTemplateTypeSpan() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateLiteralTypeSpan(
|
|
parseType(),
|
|
parseLiteralOfTemplateSpan(false)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseLiteralOfTemplateSpan(isTaggedTemplate) {
|
|
if (token() === 19 /* CloseBraceToken */) {
|
|
reScanTemplateToken(isTaggedTemplate);
|
|
return parseTemplateMiddleOrTemplateTail();
|
|
} else {
|
|
return parseExpectedToken(17 /* TemplateTail */, Diagnostics._0_expected, tokenToString(19 /* CloseBraceToken */));
|
|
}
|
|
}
|
|
function parseTemplateSpan(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateSpan(
|
|
allowInAnd(parseExpression),
|
|
parseLiteralOfTemplateSpan(isTaggedTemplate)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseLiteralNode() {
|
|
return parseLiteralLikeNode(token());
|
|
}
|
|
function parseTemplateHead(isTaggedTemplate) {
|
|
if (isTaggedTemplate) {
|
|
reScanTemplateHeadOrNoSubstitutionTemplate();
|
|
}
|
|
const fragment = parseLiteralLikeNode(token());
|
|
Debug.assert(fragment.kind === 15 /* TemplateHead */, "Template head has wrong token kind");
|
|
return fragment;
|
|
}
|
|
function parseTemplateMiddleOrTemplateTail() {
|
|
const fragment = parseLiteralLikeNode(token());
|
|
Debug.assert(fragment.kind === 16 /* TemplateMiddle */ || fragment.kind === 17 /* TemplateTail */, "Template fragment has wrong token kind");
|
|
return fragment;
|
|
}
|
|
function getTemplateLiteralRawText(kind) {
|
|
const isLast = kind === 14 /* NoSubstitutionTemplateLiteral */ || kind === 17 /* TemplateTail */;
|
|
const tokenText = scanner.getTokenText();
|
|
return tokenText.substring(1, tokenText.length - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2));
|
|
}
|
|
function parseLiteralLikeNode(kind) {
|
|
const pos = getNodePos();
|
|
const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 2048 /* TemplateLiteralLikeFlags */) : kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral(scanner.getTokenValue(), void 0, scanner.hasExtendedUnicodeEscape()) : isLiteralKind(kind) ? factory2.createLiteralLikeNode(kind, scanner.getTokenValue()) : Debug.fail();
|
|
if (scanner.hasExtendedUnicodeEscape()) {
|
|
node.hasExtendedUnicodeEscape = true;
|
|
}
|
|
if (scanner.isUnterminated()) {
|
|
node.isUnterminated = true;
|
|
}
|
|
nextToken();
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseEntityNameOfTypeReference() {
|
|
return parseEntityName(true, Diagnostics.Type_expected);
|
|
}
|
|
function parseTypeArgumentsOfTypeReference() {
|
|
if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
|
|
return parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
|
|
}
|
|
}
|
|
function parseTypeReference() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTypeReferenceNode(
|
|
parseEntityNameOfTypeReference(),
|
|
parseTypeArgumentsOfTypeReference()
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function typeHasArrowFunctionBlockingParseError(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return nodeIsMissing(node.typeName);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */: {
|
|
const { parameters, type } = node;
|
|
return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type);
|
|
}
|
|
case 193 /* ParenthesizedType */:
|
|
return typeHasArrowFunctionBlockingParseError(node.type);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function parseThisTypePredicate(lhs) {
|
|
nextToken();
|
|
return finishNode(factory2.createTypePredicateNode(void 0, lhs, parseType()), lhs.pos);
|
|
}
|
|
function parseThisTypeNode() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createThisTypeNode(), pos);
|
|
}
|
|
function parseJSDocAllType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocAllType(), pos);
|
|
}
|
|
function parseJSDocNonNullableType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocNonNullableType(parseNonArrayType(), false), pos);
|
|
}
|
|
function parseJSDocUnknownOrNullableType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
if (token() === 27 /* CommaToken */ || token() === 19 /* CloseBraceToken */ || token() === 21 /* CloseParenToken */ || token() === 31 /* GreaterThanToken */ || token() === 63 /* EqualsToken */ || token() === 51 /* BarToken */) {
|
|
return finishNode(factory2.createJSDocUnknownType(), pos);
|
|
} else {
|
|
return finishNode(factory2.createJSDocNullableType(parseType(), false), pos);
|
|
}
|
|
}
|
|
function parseJSDocFunctionType() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (lookAhead(nextTokenIsOpenParen)) {
|
|
nextToken();
|
|
const parameters = parseParameters(4 /* Type */ | 32 /* JSDoc */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
return withJSDoc(finishNode(factory2.createJSDocFunctionType(parameters, type), pos), hasJSDoc);
|
|
}
|
|
return finishNode(factory2.createTypeReferenceNode(parseIdentifierName(), void 0), pos);
|
|
}
|
|
function parseJSDocParameter() {
|
|
const pos = getNodePos();
|
|
let name;
|
|
if (token() === 108 /* ThisKeyword */ || token() === 103 /* NewKeyword */) {
|
|
name = parseIdentifierName();
|
|
parseExpected(58 /* ColonToken */);
|
|
}
|
|
return finishNode(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
parseJSDocType(),
|
|
void 0
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseJSDocType() {
|
|
scanner.setInJSDocType(true);
|
|
const pos = getNodePos();
|
|
if (parseOptional(142 /* ModuleKeyword */)) {
|
|
const moduleTag = factory2.createJSDocNamepathType(void 0);
|
|
terminate:
|
|
while (true) {
|
|
switch (token()) {
|
|
case 19 /* CloseBraceToken */:
|
|
case 1 /* EndOfFileToken */:
|
|
case 27 /* CommaToken */:
|
|
case 5 /* WhitespaceTrivia */:
|
|
break terminate;
|
|
default:
|
|
nextTokenJSDoc();
|
|
}
|
|
}
|
|
scanner.setInJSDocType(false);
|
|
return finishNode(moduleTag, pos);
|
|
}
|
|
const hasDotDotDot = parseOptional(25 /* DotDotDotToken */);
|
|
let type = parseTypeOrTypePredicate();
|
|
scanner.setInJSDocType(false);
|
|
if (hasDotDotDot) {
|
|
type = finishNode(factory2.createJSDocVariadicType(type), pos);
|
|
}
|
|
if (token() === 63 /* EqualsToken */) {
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocOptionalType(type), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeQuery() {
|
|
const pos = getNodePos();
|
|
parseExpected(112 /* TypeOfKeyword */);
|
|
const entityName = parseEntityName(true);
|
|
const typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : void 0;
|
|
return finishNode(factory2.createTypeQueryNode(entityName, typeArguments), pos);
|
|
}
|
|
function parseTypeParameter() {
|
|
const pos = getNodePos();
|
|
const modifiers = parseModifiers();
|
|
const name = parseIdentifier();
|
|
let constraint;
|
|
let expression;
|
|
if (parseOptional(94 /* ExtendsKeyword */)) {
|
|
if (isStartOfType() || !isStartOfExpression()) {
|
|
constraint = parseType();
|
|
} else {
|
|
expression = parseUnaryExpressionOrHigher();
|
|
}
|
|
}
|
|
const defaultType = parseOptional(63 /* EqualsToken */) ? parseType() : void 0;
|
|
const node = factory2.createTypeParameterDeclaration(modifiers, name, constraint, defaultType);
|
|
node.expression = expression;
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseTypeParameters() {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return parseBracketedList(ParsingContext.TypeParameters, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
|
|
}
|
|
}
|
|
function isStartOfParameter(isJSDocParameter) {
|
|
return token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern() || isModifierKind(token()) || token() === 59 /* AtToken */ || isStartOfType(!isJSDocParameter);
|
|
}
|
|
function parseNameOfParameter(modifiers) {
|
|
const name = parseIdentifierOrPattern(Diagnostics.Private_identifiers_cannot_be_used_as_parameters);
|
|
if (getFullWidth(name) === 0 && !some(modifiers) && isModifierKind(token())) {
|
|
nextToken();
|
|
}
|
|
return name;
|
|
}
|
|
function isParameterNameStart() {
|
|
return isBindingIdentifier() || token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */;
|
|
}
|
|
function parseParameter(inOuterAwaitContext) {
|
|
return parseParameterWorker(inOuterAwaitContext);
|
|
}
|
|
function parseParameterForSpeculation(inOuterAwaitContext) {
|
|
return parseParameterWorker(inOuterAwaitContext, false);
|
|
}
|
|
function parseParameterWorker(inOuterAwaitContext, allowAmbiguity = true) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators);
|
|
if (token() === 108 /* ThisKeyword */) {
|
|
const node2 = factory2.createParameterDeclaration(
|
|
decorators,
|
|
void 0,
|
|
createIdentifier(true),
|
|
void 0,
|
|
parseTypeAnnotation(),
|
|
void 0
|
|
);
|
|
if (decorators) {
|
|
parseErrorAtRange(decorators[0], Diagnostics.Decorators_may_not_be_applied_to_this_parameters);
|
|
}
|
|
return withJSDoc(finishNode(node2, pos), hasJSDoc);
|
|
}
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const modifiers = combineDecoratorsAndModifiers(decorators, parseModifiers());
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
if (!allowAmbiguity && !isParameterNameStart()) {
|
|
return void 0;
|
|
}
|
|
const node = withJSDoc(
|
|
finishNode(
|
|
factory2.createParameterDeclaration(
|
|
modifiers,
|
|
dotDotDotToken,
|
|
parseNameOfParameter(modifiers),
|
|
parseOptionalToken(57 /* 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 /* EqualsGreaterThanToken */) {
|
|
parseExpected(returnToken);
|
|
return true;
|
|
} else if (parseOptional(58 /* ColonToken */)) {
|
|
return true;
|
|
} else if (isType && token() === 38 /* EqualsGreaterThanToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(58 /* ColonToken */));
|
|
nextToken();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseParametersWorker(flags, allowAmbiguity) {
|
|
const savedYieldContext = inYieldContext();
|
|
const savedAwaitContext = inAwaitContext();
|
|
setYieldContext(!!(flags & 1 /* Yield */));
|
|
setAwaitContext(!!(flags & 2 /* Await */));
|
|
const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(ParsingContext.JSDocParameters, parseJSDocParameter) : parseDelimitedList(ParsingContext.Parameters, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return parameters;
|
|
}
|
|
function parseParameters(flags) {
|
|
if (!parseExpected(20 /* OpenParenToken */)) {
|
|
return createMissingList();
|
|
}
|
|
const parameters = parseParametersWorker(flags, true);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return parameters;
|
|
}
|
|
function parseTypeMemberSemicolon() {
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
return;
|
|
}
|
|
parseSemicolon();
|
|
}
|
|
function parseSignatureMember(kind) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (kind === 177 /* ConstructSignature */) {
|
|
parseExpected(103 /* NewKeyword */);
|
|
}
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(58 /* ColonToken */, true);
|
|
parseTypeMemberSemicolon();
|
|
const node = kind === 176 /* CallSignature */ ? factory2.createCallSignature(typeParameters, parameters, type) : factory2.createConstructSignature(typeParameters, parameters, type);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isIndexSignature() {
|
|
return token() === 22 /* OpenBracketToken */ && lookAhead(isUnambiguouslyIndexSignature);
|
|
}
|
|
function isUnambiguouslyIndexSignature() {
|
|
nextToken();
|
|
if (token() === 25 /* DotDotDotToken */ || token() === 23 /* CloseBracketToken */) {
|
|
return true;
|
|
}
|
|
if (isModifierKind(token())) {
|
|
nextToken();
|
|
if (isIdentifier2()) {
|
|
return true;
|
|
}
|
|
} else if (!isIdentifier2()) {
|
|
return false;
|
|
} else {
|
|
nextToken();
|
|
}
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */) {
|
|
return true;
|
|
}
|
|
if (token() !== 57 /* QuestionToken */) {
|
|
return false;
|
|
}
|
|
nextToken();
|
|
return token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 23 /* CloseBracketToken */;
|
|
}
|
|
function parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const parameters = parseBracketedList(ParsingContext.Parameters, () => parseParameter(false), 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
|
|
const type = parseTypeAnnotation();
|
|
parseTypeMemberSemicolon();
|
|
const node = factory2.createIndexSignature(modifiers, parameters, type);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers) {
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
let node;
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(58 /* ColonToken */, true);
|
|
node = factory2.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type);
|
|
} else {
|
|
const type = parseTypeAnnotation();
|
|
node = factory2.createPropertySignature(modifiers, name, questionToken, type);
|
|
if (token() === 63 /* EqualsToken */)
|
|
node.initializer = parseInitializer();
|
|
}
|
|
parseTypeMemberSemicolon();
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isTypeMemberStart() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 137 /* GetKeyword */ || token() === 151 /* SetKeyword */) {
|
|
return true;
|
|
}
|
|
let idToken = false;
|
|
while (isModifierKind(token())) {
|
|
idToken = true;
|
|
nextToken();
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return true;
|
|
}
|
|
if (isLiteralPropertyName()) {
|
|
idToken = true;
|
|
nextToken();
|
|
}
|
|
if (idToken) {
|
|
return token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 57 /* QuestionToken */ || token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || canParseSemicolon();
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeMember() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseSignatureMember(176 /* CallSignature */);
|
|
}
|
|
if (token() === 103 /* NewKeyword */ && lookAhead(nextTokenIsOpenParenOrLessThan)) {
|
|
return parseSignatureMember(177 /* ConstructSignature */);
|
|
}
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiers();
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, void 0, modifiers, 174 /* GetAccessor */, 4 /* Type */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, void 0, modifiers, 175 /* SetAccessor */, 4 /* Type */);
|
|
}
|
|
if (isIndexSignature()) {
|
|
return parseIndexSignatureDeclaration(pos, hasJSDoc, void 0, modifiers);
|
|
}
|
|
return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers);
|
|
}
|
|
function nextTokenIsOpenParenOrLessThan() {
|
|
nextToken();
|
|
return token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */;
|
|
}
|
|
function nextTokenIsDot() {
|
|
return nextToken() === 24 /* DotToken */;
|
|
}
|
|
function nextTokenIsOpenParenOrLessThanOrDot() {
|
|
switch (nextToken()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeLiteral() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createTypeLiteralNode(parseObjectTypeMembers()), pos);
|
|
}
|
|
function parseObjectTypeMembers() {
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = parseList(ParsingContext.TypeMembers, parseTypeMember);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
return members;
|
|
}
|
|
function isStartOfMappedType() {
|
|
nextToken();
|
|
if (token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
return nextToken() === 146 /* ReadonlyKeyword */;
|
|
}
|
|
if (token() === 146 /* ReadonlyKeyword */) {
|
|
nextToken();
|
|
}
|
|
return token() === 22 /* OpenBracketToken */ && nextTokenIsIdentifier() && nextToken() === 101 /* InKeyword */;
|
|
}
|
|
function parseMappedTypeParameter() {
|
|
const pos = getNodePos();
|
|
const name = parseIdentifierName();
|
|
parseExpected(101 /* InKeyword */);
|
|
const type = parseType();
|
|
return finishNode(factory2.createTypeParameterDeclaration(void 0, name, type, void 0), pos);
|
|
}
|
|
function parseMappedType() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
let readonlyToken;
|
|
if (token() === 146 /* ReadonlyKeyword */ || token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
readonlyToken = parseTokenNode();
|
|
if (readonlyToken.kind !== 146 /* ReadonlyKeyword */) {
|
|
parseExpected(146 /* ReadonlyKeyword */);
|
|
}
|
|
}
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const typeParameter = parseMappedTypeParameter();
|
|
const nameType = parseOptional(128 /* AsKeyword */) ? parseType() : void 0;
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
let questionToken;
|
|
if (token() === 57 /* QuestionToken */ || token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
questionToken = parseTokenNode();
|
|
if (questionToken.kind !== 57 /* QuestionToken */) {
|
|
parseExpected(57 /* QuestionToken */);
|
|
}
|
|
}
|
|
const type = parseTypeAnnotation();
|
|
parseSemicolon();
|
|
const members = parseList(ParsingContext.TypeMembers, parseTypeMember);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
|
|
}
|
|
function parseTupleElementType() {
|
|
const pos = getNodePos();
|
|
if (parseOptional(25 /* DotDotDotToken */)) {
|
|
return finishNode(factory2.createRestTypeNode(parseType()), pos);
|
|
}
|
|
const type = parseType();
|
|
if (isJSDocNullableType(type) && type.pos === type.type.pos) {
|
|
const node = factory2.createOptionalTypeNode(type.type);
|
|
setTextRange(node, type);
|
|
node.flags = type.flags;
|
|
return node;
|
|
}
|
|
return type;
|
|
}
|
|
function isNextTokenColonOrQuestionColon() {
|
|
return nextToken() === 58 /* ColonToken */ || token() === 57 /* QuestionToken */ && nextToken() === 58 /* ColonToken */;
|
|
}
|
|
function isTupleElementName() {
|
|
if (token() === 25 /* DotDotDotToken */) {
|
|
return tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
|
|
}
|
|
return tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
|
|
}
|
|
function parseTupleElementNameOrTupleElementType() {
|
|
if (lookAhead(isTupleElementName)) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const name = parseIdentifierName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const type = parseTupleElementType();
|
|
const node = factory2.createNamedTupleMember(dotDotDotToken, name, questionToken, type);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
return parseTupleElementType();
|
|
}
|
|
function parseTupleType() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTupleTypeNode(
|
|
parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseParenthesizedType() {
|
|
const pos = getNodePos();
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const type = parseType();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return finishNode(factory2.createParenthesizedType(type), pos);
|
|
}
|
|
function parseModifiersForConstructorType() {
|
|
let modifiers;
|
|
if (token() === 126 /* AbstractKeyword */) {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
const modifier = finishNode(factory2.createToken(126 /* AbstractKeyword */), pos);
|
|
modifiers = createNodeArray([modifier], pos);
|
|
}
|
|
return modifiers;
|
|
}
|
|
function parseFunctionOrConstructorType() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiersForConstructorType();
|
|
const isConstructorType = parseOptional(103 /* NewKeyword */);
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(38 /* EqualsGreaterThanToken */, false);
|
|
const node = isConstructorType ? factory2.createConstructorTypeNode(modifiers, typeParameters, parameters, type) : factory2.createFunctionTypeNode(typeParameters, parameters, type);
|
|
if (!isConstructorType)
|
|
node.modifiers = modifiers;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseKeywordAndNoDot() {
|
|
const node = parseTokenNode();
|
|
return token() === 24 /* DotToken */ ? void 0 : node;
|
|
}
|
|
function parseLiteralTypeNode(negative) {
|
|
const pos = getNodePos();
|
|
if (negative) {
|
|
nextToken();
|
|
}
|
|
let expression = token() === 110 /* TrueKeyword */ || token() === 95 /* FalseKeyword */ || token() === 104 /* NullKeyword */ ? parseTokenNode() : parseLiteralLikeNode(token());
|
|
if (negative) {
|
|
expression = finishNode(factory2.createPrefixUnaryExpression(40 /* MinusToken */, expression), pos);
|
|
}
|
|
return finishNode(factory2.createLiteralTypeNode(expression), pos);
|
|
}
|
|
function isStartOfTypeOfImportType() {
|
|
nextToken();
|
|
return token() === 100 /* ImportKeyword */;
|
|
}
|
|
function parseImportTypeAssertions() {
|
|
const pos = getNodePos();
|
|
const openBracePosition = scanner.getTokenPos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const multiLine = scanner.hasPrecedingLineBreak();
|
|
parseExpected(130 /* AssertKeyword */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const clause = parseAssertClause(true);
|
|
if (!parseExpected(19 /* CloseBraceToken */)) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
if (lastError && lastError.code === Diagnostics._0_expected.code) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")
|
|
);
|
|
}
|
|
}
|
|
return finishNode(factory2.createImportTypeAssertionContainer(clause, multiLine), pos);
|
|
}
|
|
function parseImportType() {
|
|
sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
|
|
const pos = getNodePos();
|
|
const isTypeOf = parseOptional(112 /* TypeOfKeyword */);
|
|
parseExpected(100 /* ImportKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const type = parseType();
|
|
let assertions;
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
assertions = parseImportTypeAssertions();
|
|
}
|
|
parseExpected(21 /* CloseParenToken */);
|
|
const qualifier = parseOptional(24 /* DotToken */) ? parseEntityNameOfTypeReference() : void 0;
|
|
const typeArguments = parseTypeArgumentsOfTypeReference();
|
|
return finishNode(factory2.createImportTypeNode(type, assertions, qualifier, typeArguments, isTypeOf), pos);
|
|
}
|
|
function nextTokenIsNumericOrBigIntLiteral() {
|
|
nextToken();
|
|
return token() === 8 /* NumericLiteral */ || token() === 9 /* BigIntLiteral */;
|
|
}
|
|
function parseNonArrayType() {
|
|
switch (token()) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
return tryParse(parseKeywordAndNoDot) || parseTypeReference();
|
|
case 66 /* AsteriskEqualsToken */:
|
|
scanner.reScanAsteriskEqualsToken();
|
|
case 41 /* AsteriskToken */:
|
|
return parseJSDocAllType();
|
|
case 60 /* QuestionQuestionToken */:
|
|
scanner.reScanQuestionToken();
|
|
case 57 /* QuestionToken */:
|
|
return parseJSDocUnknownOrNullableType();
|
|
case 98 /* FunctionKeyword */:
|
|
return parseJSDocFunctionType();
|
|
case 53 /* ExclamationToken */:
|
|
return parseJSDocNonNullableType();
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
return parseLiteralTypeNode();
|
|
case 40 /* MinusToken */:
|
|
return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(true) : parseTypeReference();
|
|
case 114 /* VoidKeyword */:
|
|
return parseTokenNode();
|
|
case 108 /* ThisKeyword */: {
|
|
const thisKeyword = parseThisTypeNode();
|
|
if (token() === 140 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) {
|
|
return parseThisTypePredicate(thisKeyword);
|
|
} else {
|
|
return thisKeyword;
|
|
}
|
|
}
|
|
case 112 /* TypeOfKeyword */:
|
|
return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery();
|
|
case 18 /* OpenBraceToken */:
|
|
return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral();
|
|
case 22 /* OpenBracketToken */:
|
|
return parseTupleType();
|
|
case 20 /* OpenParenToken */:
|
|
return parseParenthesizedType();
|
|
case 100 /* ImportKeyword */:
|
|
return parseImportType();
|
|
case 129 /* AssertsKeyword */:
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
|
|
case 15 /* TemplateHead */:
|
|
return parseTemplateType();
|
|
default:
|
|
return parseTypeReference();
|
|
}
|
|
}
|
|
function isStartOfType(inStartOfParameter) {
|
|
switch (token()) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 156 /* UniqueKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 108 /* ThisKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 22 /* OpenBracketToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 51 /* BarToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 103 /* NewKeyword */:
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 41 /* AsteriskToken */:
|
|
case 57 /* QuestionToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 25 /* DotDotDotToken */:
|
|
case 138 /* InferKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
case 129 /* AssertsKeyword */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
return true;
|
|
case 98 /* FunctionKeyword */:
|
|
return !inStartOfParameter;
|
|
case 40 /* MinusToken */:
|
|
return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral);
|
|
case 20 /* OpenParenToken */:
|
|
return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType);
|
|
default:
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfParenthesizedOrFunctionType() {
|
|
nextToken();
|
|
return token() === 21 /* CloseParenToken */ || isStartOfParameter(false) || isStartOfType();
|
|
}
|
|
function parsePostfixTypeOrHigher() {
|
|
const pos = getNodePos();
|
|
let type = parseNonArrayType();
|
|
while (!scanner.hasPrecedingLineBreak()) {
|
|
switch (token()) {
|
|
case 53 /* ExclamationToken */:
|
|
nextToken();
|
|
type = finishNode(factory2.createJSDocNonNullableType(type, true), pos);
|
|
break;
|
|
case 57 /* QuestionToken */:
|
|
if (lookAhead(nextTokenIsStartOfType)) {
|
|
return type;
|
|
}
|
|
nextToken();
|
|
type = finishNode(factory2.createJSDocNullableType(type, true), pos);
|
|
break;
|
|
case 22 /* OpenBracketToken */:
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
if (isStartOfType()) {
|
|
const indexType = parseType();
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
type = finishNode(factory2.createIndexedAccessTypeNode(type, indexType), pos);
|
|
} else {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
type = finishNode(factory2.createArrayTypeNode(type), pos);
|
|
}
|
|
break;
|
|
default:
|
|
return type;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeOperator(operator) {
|
|
const pos = getNodePos();
|
|
parseExpected(operator);
|
|
return finishNode(factory2.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
|
|
}
|
|
function tryParseConstraintOfInferType() {
|
|
if (parseOptional(94 /* ExtendsKeyword */)) {
|
|
const constraint = disallowConditionalTypesAnd(parseType);
|
|
if (inDisallowConditionalTypesContext() || token() !== 57 /* QuestionToken */) {
|
|
return constraint;
|
|
}
|
|
}
|
|
}
|
|
function parseTypeParameterOfInferType() {
|
|
const pos = getNodePos();
|
|
const name = parseIdentifier();
|
|
const constraint = tryParse(tryParseConstraintOfInferType);
|
|
const node = factory2.createTypeParameterDeclaration(void 0, name, constraint);
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseInferType() {
|
|
const pos = getNodePos();
|
|
parseExpected(138 /* InferKeyword */);
|
|
return finishNode(factory2.createInferTypeNode(parseTypeParameterOfInferType()), pos);
|
|
}
|
|
function parseTypeOperatorOrHigher() {
|
|
const operator = token();
|
|
switch (operator) {
|
|
case 141 /* KeyOfKeyword */:
|
|
case 156 /* UniqueKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
return parseTypeOperator(operator);
|
|
case 138 /* InferKeyword */:
|
|
return parseInferType();
|
|
}
|
|
return allowConditionalTypesAnd(parsePostfixTypeOrHigher);
|
|
}
|
|
function parseFunctionOrConstructorTypeToError(isInUnionType) {
|
|
if (isStartOfFunctionTypeOrConstructorType()) {
|
|
const type = parseFunctionOrConstructorType();
|
|
let diagnostic;
|
|
if (isFunctionTypeNode(type)) {
|
|
diagnostic = isInUnionType ? Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type : Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
|
|
} else {
|
|
diagnostic = isInUnionType ? Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type : Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
|
|
}
|
|
parseErrorAtRange(type, diagnostic);
|
|
return type;
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseUnionOrIntersectionType(operator, parseConstituentType, createTypeNode) {
|
|
const pos = getNodePos();
|
|
const isUnionType = operator === 51 /* BarToken */;
|
|
const hasLeadingOperator = parseOptional(operator);
|
|
let type = hasLeadingOperator && parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType();
|
|
if (token() === operator || hasLeadingOperator) {
|
|
const types = [type];
|
|
while (parseOptional(operator)) {
|
|
types.push(parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType());
|
|
}
|
|
type = finishNode(createTypeNode(createNodeArray(types, pos)), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseIntersectionTypeOrHigher() {
|
|
return parseUnionOrIntersectionType(50 /* AmpersandToken */, parseTypeOperatorOrHigher, factory2.createIntersectionTypeNode);
|
|
}
|
|
function parseUnionTypeOrHigher() {
|
|
return parseUnionOrIntersectionType(51 /* BarToken */, parseIntersectionTypeOrHigher, factory2.createUnionTypeNode);
|
|
}
|
|
function nextTokenIsNewKeyword() {
|
|
nextToken();
|
|
return token() === 103 /* NewKeyword */;
|
|
}
|
|
function isStartOfFunctionTypeOrConstructorType() {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return true;
|
|
}
|
|
if (token() === 20 /* OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType)) {
|
|
return true;
|
|
}
|
|
return token() === 103 /* NewKeyword */ || token() === 126 /* AbstractKeyword */ && lookAhead(nextTokenIsNewKeyword);
|
|
}
|
|
function skipParameterStart() {
|
|
if (isModifierKind(token())) {
|
|
parseModifiers();
|
|
}
|
|
if (isIdentifier2() || token() === 108 /* ThisKeyword */) {
|
|
nextToken();
|
|
return true;
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */) {
|
|
const previousErrorCount = parseDiagnostics.length;
|
|
parseIdentifierOrPattern();
|
|
return previousErrorCount === parseDiagnostics.length;
|
|
}
|
|
return false;
|
|
}
|
|
function isUnambiguouslyStartOfFunctionType() {
|
|
nextToken();
|
|
if (token() === 21 /* CloseParenToken */ || token() === 25 /* DotDotDotToken */) {
|
|
return true;
|
|
}
|
|
if (skipParameterStart()) {
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 57 /* QuestionToken */ || token() === 63 /* EqualsToken */) {
|
|
return true;
|
|
}
|
|
if (token() === 21 /* CloseParenToken */) {
|
|
nextToken();
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeOrTypePredicate() {
|
|
const pos = getNodePos();
|
|
const typePredicateVariable = isIdentifier2() && tryParse(parseTypePredicatePrefix);
|
|
const type = parseType();
|
|
if (typePredicateVariable) {
|
|
return finishNode(factory2.createTypePredicateNode(void 0, typePredicateVariable, type), pos);
|
|
} else {
|
|
return type;
|
|
}
|
|
}
|
|
function parseTypePredicatePrefix() {
|
|
const id = parseIdentifier();
|
|
if (token() === 140 /* IsKeyword */ && !scanner.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
return id;
|
|
}
|
|
}
|
|
function parseAssertsTypePredicate() {
|
|
const pos = getNodePos();
|
|
const assertsModifier = parseExpectedToken(129 /* AssertsKeyword */);
|
|
const parameterName = token() === 108 /* ThisKeyword */ ? parseThisTypeNode() : parseIdentifier();
|
|
const type = parseOptional(140 /* IsKeyword */) ? parseType() : void 0;
|
|
return finishNode(factory2.createTypePredicateNode(assertsModifier, parameterName, type), pos);
|
|
}
|
|
function parseType() {
|
|
if (contextFlags & 40960 /* TypeExcludesFlags */) {
|
|
return doOutsideOfContext(40960 /* TypeExcludesFlags */, parseType);
|
|
}
|
|
if (isStartOfFunctionTypeOrConstructorType()) {
|
|
return parseFunctionOrConstructorType();
|
|
}
|
|
const pos = getNodePos();
|
|
const type = parseUnionTypeOrHigher();
|
|
if (!inDisallowConditionalTypesContext() && !scanner.hasPrecedingLineBreak() && parseOptional(94 /* ExtendsKeyword */)) {
|
|
const extendsType = disallowConditionalTypesAnd(parseType);
|
|
parseExpected(57 /* QuestionToken */);
|
|
const trueType = allowConditionalTypesAnd(parseType);
|
|
parseExpected(58 /* ColonToken */);
|
|
const falseType = allowConditionalTypesAnd(parseType);
|
|
return finishNode(factory2.createConditionalTypeNode(type, extendsType, trueType, falseType), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeAnnotation() {
|
|
return parseOptional(58 /* ColonToken */) ? parseType() : void 0;
|
|
}
|
|
function isStartOfLeftHandSideExpression() {
|
|
switch (token()) {
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 20 /* OpenParenToken */:
|
|
case 22 /* OpenBracketToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 103 /* NewKeyword */:
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 79 /* Identifier */:
|
|
return true;
|
|
case 100 /* ImportKeyword */:
|
|
return lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
|
|
default:
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfExpression() {
|
|
if (isStartOfLeftHandSideExpression()) {
|
|
return true;
|
|
}
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 89 /* DeleteKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 133 /* AwaitKeyword */:
|
|
case 125 /* YieldKeyword */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return true;
|
|
default:
|
|
if (isBinaryOperator2()) {
|
|
return true;
|
|
}
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfExpressionStatement() {
|
|
return token() !== 18 /* OpenBraceToken */ && token() !== 98 /* FunctionKeyword */ && token() !== 84 /* ClassKeyword */ && token() !== 59 /* AtToken */ && isStartOfExpression();
|
|
}
|
|
function parseExpression() {
|
|
const saveDecoratorContext = inDecoratorContext();
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(false);
|
|
}
|
|
const pos = getNodePos();
|
|
let expr = parseAssignmentExpressionOrHigher(true);
|
|
let operatorToken;
|
|
while (operatorToken = parseOptionalToken(27 /* CommaToken */)) {
|
|
expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(true), pos);
|
|
}
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(true);
|
|
}
|
|
return expr;
|
|
}
|
|
function parseInitializer() {
|
|
return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(true) : void 0;
|
|
}
|
|
function parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) {
|
|
if (isYieldExpression()) {
|
|
return parseYieldExpression();
|
|
}
|
|
const arrowExpression = tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction);
|
|
if (arrowExpression) {
|
|
return arrowExpression;
|
|
}
|
|
const pos = getNodePos();
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
|
|
return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, void 0);
|
|
}
|
|
if (isLeftHandSideExpression(expr) && isAssignmentOperator(reScanGreaterToken())) {
|
|
return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction), pos);
|
|
}
|
|
return parseConditionalExpressionRest(expr, pos, allowReturnTypeInArrowFunction);
|
|
}
|
|
function isYieldExpression() {
|
|
if (token() === 125 /* YieldKeyword */) {
|
|
if (inYieldContext()) {
|
|
return true;
|
|
}
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
|
|
}
|
|
return false;
|
|
}
|
|
function nextTokenIsIdentifierOnSameLine() {
|
|
nextToken();
|
|
return !scanner.hasPrecedingLineBreak() && isIdentifier2();
|
|
}
|
|
function parseYieldExpression() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
if (!scanner.hasPrecedingLineBreak() && (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
|
|
return finishNode(
|
|
factory2.createYieldExpression(
|
|
parseOptionalToken(41 /* AsteriskToken */),
|
|
parseAssignmentExpressionOrHigher(true)
|
|
),
|
|
pos
|
|
);
|
|
} else {
|
|
return finishNode(factory2.createYieldExpression(void 0, void 0), pos);
|
|
}
|
|
}
|
|
function parseSimpleArrowFunctionExpression(pos, identifier, allowReturnTypeInArrowFunction, asyncModifier) {
|
|
Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
|
|
const parameter = factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
identifier,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
finishNode(parameter, identifier.pos);
|
|
const parameters = createNodeArray([parameter], parameter.pos, parameter.end);
|
|
const equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
|
|
const body = parseArrowFunctionExpressionBody(!!asyncModifier, allowReturnTypeInArrowFunction);
|
|
const node = factory2.createArrowFunction(asyncModifier, void 0, parameters, void 0, equalsGreaterThanToken, body);
|
|
return addJSDocComment(finishNode(node, pos));
|
|
}
|
|
function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
const triState = isParenthesizedArrowFunctionExpression();
|
|
if (triState === Tristate.False) {
|
|
return void 0;
|
|
}
|
|
return triState === Tristate.True ? parseParenthesizedArrowFunctionExpression(true, true) : tryParse(() => parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction));
|
|
}
|
|
function isParenthesizedArrowFunctionExpression() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 132 /* AsyncKeyword */) {
|
|
return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
|
|
}
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
function isParenthesizedArrowFunctionExpressionWorker() {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
nextToken();
|
|
if (scanner.hasPrecedingLineBreak()) {
|
|
return Tristate.False;
|
|
}
|
|
if (token() !== 20 /* OpenParenToken */ && token() !== 29 /* LessThanToken */) {
|
|
return Tristate.False;
|
|
}
|
|
}
|
|
const first2 = token();
|
|
const second = nextToken();
|
|
if (first2 === 20 /* OpenParenToken */) {
|
|
if (second === 21 /* CloseParenToken */) {
|
|
const third = nextToken();
|
|
switch (third) {
|
|
case 38 /* EqualsGreaterThanToken */:
|
|
case 58 /* ColonToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
return Tristate.True;
|
|
default:
|
|
return Tristate.False;
|
|
}
|
|
}
|
|
if (second === 22 /* OpenBracketToken */ || second === 18 /* OpenBraceToken */) {
|
|
return Tristate.Unknown;
|
|
}
|
|
if (second === 25 /* DotDotDotToken */) {
|
|
return Tristate.True;
|
|
}
|
|
if (isModifierKind(second) && second !== 132 /* AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) {
|
|
if (nextToken() === 128 /* AsKeyword */) {
|
|
return Tristate.False;
|
|
}
|
|
return Tristate.True;
|
|
}
|
|
if (!isIdentifier2() && second !== 108 /* ThisKeyword */) {
|
|
return Tristate.False;
|
|
}
|
|
switch (nextToken()) {
|
|
case 58 /* ColonToken */:
|
|
return Tristate.True;
|
|
case 57 /* QuestionToken */:
|
|
nextToken();
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 63 /* EqualsToken */ || token() === 21 /* CloseParenToken */) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
case 27 /* CommaToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 21 /* CloseParenToken */:
|
|
return Tristate.Unknown;
|
|
}
|
|
return Tristate.False;
|
|
} else {
|
|
Debug.assert(first2 === 29 /* LessThanToken */);
|
|
if (!isIdentifier2()) {
|
|
return Tristate.False;
|
|
}
|
|
if (languageVariant === 1 /* JSX */) {
|
|
const isArrowFunctionInJsx = lookAhead(() => {
|
|
const third = nextToken();
|
|
if (third === 94 /* ExtendsKeyword */) {
|
|
const fourth = nextToken();
|
|
switch (fourth) {
|
|
case 63 /* EqualsToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
} else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
if (isArrowFunctionInJsx) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
return Tristate.Unknown;
|
|
}
|
|
}
|
|
function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
const tokenPos = scanner.getTokenPos();
|
|
if (notParenthesizedArrow == null ? void 0 : notParenthesizedArrow.has(tokenPos)) {
|
|
return void 0;
|
|
}
|
|
const result = parseParenthesizedArrowFunctionExpression(false, allowReturnTypeInArrowFunction);
|
|
if (!result) {
|
|
(notParenthesizedArrow || (notParenthesizedArrow = /* @__PURE__ */ new Set())).add(tokenPos);
|
|
}
|
|
return result;
|
|
}
|
|
function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === Tristate.True) {
|
|
const pos = getNodePos();
|
|
const asyncModifier = parseModifiersForArrowFunction();
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, asyncModifier);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isUnParenthesizedAsyncArrowFunctionWorker() {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
nextToken();
|
|
if (scanner.hasPrecedingLineBreak() || token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.False;
|
|
}
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
if (!scanner.hasPrecedingLineBreak() && expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.True;
|
|
}
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiersForArrowFunction();
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
let parameters;
|
|
if (!parseExpected(20 /* OpenParenToken */)) {
|
|
if (!allowAmbiguity) {
|
|
return void 0;
|
|
}
|
|
parameters = createMissingList();
|
|
} else {
|
|
if (!allowAmbiguity) {
|
|
const maybeParameters = parseParametersWorker(isAsync, allowAmbiguity);
|
|
if (!maybeParameters) {
|
|
return void 0;
|
|
}
|
|
parameters = maybeParameters;
|
|
} else {
|
|
parameters = parseParametersWorker(isAsync, allowAmbiguity);
|
|
}
|
|
if (!parseExpected(21 /* CloseParenToken */) && !allowAmbiguity) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const hasReturnColon = token() === 58 /* ColonToken */;
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
|
|
return void 0;
|
|
}
|
|
let unwrappedType = type;
|
|
while ((unwrappedType == null ? void 0 : unwrappedType.kind) === 193 /* ParenthesizedType */) {
|
|
unwrappedType = unwrappedType.type;
|
|
}
|
|
const hasJSDocFunctionType = unwrappedType && isJSDocFunctionType(unwrappedType);
|
|
if (!allowAmbiguity && token() !== 38 /* EqualsGreaterThanToken */ && (hasJSDocFunctionType || token() !== 18 /* OpenBraceToken */)) {
|
|
return void 0;
|
|
}
|
|
const lastToken = token();
|
|
const equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
|
|
const body = lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */ ? parseArrowFunctionExpressionBody(some(modifiers, isAsyncModifier), allowReturnTypeInArrowFunction) : parseIdentifier();
|
|
if (!allowReturnTypeInArrowFunction && hasReturnColon) {
|
|
if (token() !== 58 /* ColonToken */) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const node = factory2.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseArrowFunctionExpressionBody(isAsync, allowReturnTypeInArrowFunction) {
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
|
|
}
|
|
if (token() !== 26 /* SemicolonToken */ && token() !== 98 /* FunctionKeyword */ && token() !== 84 /* ClassKeyword */ && isStartOfStatement() && !isStartOfExpressionStatement()) {
|
|
return parseFunctionBlock(16 /* IgnoreMissingOpenBrace */ | (isAsync ? 2 /* Await */ : 0 /* None */));
|
|
}
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const node = isAsync ? doInAwaitContext(() => parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction)) : doOutsideOfAwaitContext(() => parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction));
|
|
topLevel = savedTopLevel;
|
|
return node;
|
|
}
|
|
function parseConditionalExpressionRest(leftOperand, pos, allowReturnTypeInArrowFunction) {
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
if (!questionToken) {
|
|
return leftOperand;
|
|
}
|
|
let colonToken;
|
|
return finishNode(
|
|
factory2.createConditionalExpression(
|
|
leftOperand,
|
|
questionToken,
|
|
doOutsideOfContext(disallowInAndDecoratorContext, () => parseAssignmentExpressionOrHigher(false)),
|
|
colonToken = parseExpectedToken(58 /* ColonToken */),
|
|
nodeIsPresent(colonToken) ? parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) : createMissingNode(79 /* Identifier */, false, Diagnostics._0_expected, tokenToString(58 /* ColonToken */))
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseBinaryExpressionOrHigher(precedence) {
|
|
const pos = getNodePos();
|
|
const leftOperand = parseUnaryExpressionOrHigher();
|
|
return parseBinaryExpressionRest(precedence, leftOperand, pos);
|
|
}
|
|
function isInOrOfKeyword(t) {
|
|
return t === 101 /* InKeyword */ || t === 162 /* OfKeyword */;
|
|
}
|
|
function parseBinaryExpressionRest(precedence, leftOperand, pos) {
|
|
while (true) {
|
|
reScanGreaterToken();
|
|
const newPrecedence = getBinaryOperatorPrecedence(token());
|
|
const consumeCurrentOperator = token() === 42 /* AsteriskAsteriskToken */ ? newPrecedence >= precedence : newPrecedence > precedence;
|
|
if (!consumeCurrentOperator) {
|
|
break;
|
|
}
|
|
if (token() === 101 /* InKeyword */ && inDisallowInContext()) {
|
|
break;
|
|
}
|
|
if (token() === 128 /* AsKeyword */ || token() === 150 /* SatisfiesKeyword */) {
|
|
if (scanner.hasPrecedingLineBreak()) {
|
|
break;
|
|
} else {
|
|
const keywordKind = token();
|
|
nextToken();
|
|
leftOperand = keywordKind === 150 /* SatisfiesKeyword */ ? makeSatisfiesExpression(leftOperand, parseType()) : makeAsExpression(leftOperand, parseType());
|
|
}
|
|
} else {
|
|
leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence), pos);
|
|
}
|
|
}
|
|
return leftOperand;
|
|
}
|
|
function isBinaryOperator2() {
|
|
if (inDisallowInContext() && token() === 101 /* InKeyword */) {
|
|
return false;
|
|
}
|
|
return getBinaryOperatorPrecedence(token()) > 0;
|
|
}
|
|
function makeSatisfiesExpression(left, right) {
|
|
return finishNode(factory2.createSatisfiesExpression(left, right), left.pos);
|
|
}
|
|
function makeBinaryExpression(left, operatorToken, right, pos) {
|
|
return finishNode(factory2.createBinaryExpression(left, operatorToken, right), pos);
|
|
}
|
|
function makeAsExpression(left, right) {
|
|
return finishNode(factory2.createAsExpression(left, right), left.pos);
|
|
}
|
|
function parsePrefixUnaryExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createPrefixUnaryExpression(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseDeleteExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseTypeOfExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createTypeOfExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseVoidExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createVoidExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function isAwaitExpression() {
|
|
if (token() === 133 /* AwaitKeyword */) {
|
|
if (inAwaitContext()) {
|
|
return true;
|
|
}
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
|
|
}
|
|
return false;
|
|
}
|
|
function parseAwaitExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createAwaitExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseUnaryExpressionOrHigher() {
|
|
if (isUpdateExpression()) {
|
|
const pos = getNodePos();
|
|
const updateExpression = parseUpdateExpression();
|
|
return token() === 42 /* AsteriskAsteriskToken */ ? parseBinaryExpressionRest(getBinaryOperatorPrecedence(token()), updateExpression, pos) : updateExpression;
|
|
}
|
|
const unaryOperator = token();
|
|
const simpleUnaryExpression = parseSimpleUnaryExpression();
|
|
if (token() === 42 /* AsteriskAsteriskToken */) {
|
|
const pos = skipTrivia(sourceText, simpleUnaryExpression.pos);
|
|
const { end } = simpleUnaryExpression;
|
|
if (simpleUnaryExpression.kind === 213 /* TypeAssertionExpression */) {
|
|
parseErrorAt(pos, end, 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, 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, tokenToString(unaryOperator));
|
|
}
|
|
}
|
|
return simpleUnaryExpression;
|
|
}
|
|
function parseSimpleUnaryExpression() {
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
return parsePrefixUnaryExpression();
|
|
case 89 /* DeleteKeyword */:
|
|
return parseDeleteExpression();
|
|
case 112 /* TypeOfKeyword */:
|
|
return parseTypeOfExpression();
|
|
case 114 /* VoidKeyword */:
|
|
return parseVoidExpression();
|
|
case 29 /* LessThanToken */:
|
|
return parseTypeAssertion();
|
|
case 133 /* AwaitKeyword */:
|
|
if (isAwaitExpression()) {
|
|
return parseAwaitExpression();
|
|
}
|
|
default:
|
|
return parseUpdateExpression();
|
|
}
|
|
}
|
|
function isUpdateExpression() {
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 89 /* DeleteKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 133 /* AwaitKeyword */:
|
|
return false;
|
|
case 29 /* LessThanToken */:
|
|
if (languageVariant !== 1 /* JSX */) {
|
|
return false;
|
|
}
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function parseUpdateExpression() {
|
|
if (token() === 45 /* PlusPlusToken */ || token() === 46 /* MinusMinusToken */) {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createPrefixUnaryExpression(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos);
|
|
} else if (languageVariant === 1 /* JSX */ && token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
|
|
return parseJsxElementOrSelfClosingElementOrFragment(true);
|
|
}
|
|
const expression = parseLeftHandSideExpressionOrHigher();
|
|
Debug.assert(isLeftHandSideExpression(expression));
|
|
if ((token() === 45 /* PlusPlusToken */ || token() === 46 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) {
|
|
const operator = token();
|
|
nextToken();
|
|
return finishNode(factory2.createPostfixUnaryExpression(expression, operator), expression.pos);
|
|
}
|
|
return expression;
|
|
}
|
|
function parseLeftHandSideExpressionOrHigher() {
|
|
const pos = getNodePos();
|
|
let expression;
|
|
if (token() === 100 /* ImportKeyword */) {
|
|
if (lookAhead(nextTokenIsOpenParenOrLessThan)) {
|
|
sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
|
|
expression = parseTokenNode();
|
|
} else if (lookAhead(nextTokenIsDot)) {
|
|
nextToken();
|
|
nextToken();
|
|
expression = finishNode(factory2.createMetaProperty(100 /* ImportKeyword */, parseIdentifierName()), pos);
|
|
sourceFlags |= 4194304 /* PossiblyContainsImportMeta */;
|
|
} else {
|
|
expression = parseMemberExpressionOrHigher();
|
|
}
|
|
} else {
|
|
expression = token() === 106 /* SuperKeyword */ ? parseSuperExpression() : parseMemberExpressionOrHigher();
|
|
}
|
|
return parseCallExpressionRest(pos, expression);
|
|
}
|
|
function parseMemberExpressionOrHigher() {
|
|
const pos = getNodePos();
|
|
const expression = parsePrimaryExpression();
|
|
return parseMemberExpressionRest(pos, expression, true);
|
|
}
|
|
function parseSuperExpression() {
|
|
const pos = getNodePos();
|
|
let expression = parseTokenNode();
|
|
if (token() === 29 /* LessThanToken */) {
|
|
const startPos = getNodePos();
|
|
const typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (typeArguments !== void 0) {
|
|
parseErrorAt(startPos, getNodePos(), Diagnostics.super_may_not_use_type_arguments);
|
|
if (!isTemplateStartOfTaggedTemplate()) {
|
|
expression = factory2.createExpressionWithTypeArguments(expression, typeArguments);
|
|
}
|
|
}
|
|
}
|
|
if (token() === 20 /* OpenParenToken */ || token() === 24 /* DotToken */ || token() === 22 /* OpenBracketToken */) {
|
|
return expression;
|
|
}
|
|
parseExpectedToken(24 /* DotToken */, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
|
|
return finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(true, true)), pos);
|
|
}
|
|
function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition, openingTag) {
|
|
const pos = getNodePos();
|
|
const opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
|
|
let result;
|
|
if (opening.kind === 283 /* JsxOpeningElement */) {
|
|
let children = parseJsxChildren(opening);
|
|
let closingElement;
|
|
const lastChild = children[children.length - 1];
|
|
if ((lastChild == null ? void 0 : lastChild.kind) === 281 /* JsxElement */ && !tagNamesAreEquivalent(lastChild.openingElement.tagName, lastChild.closingElement.tagName) && tagNamesAreEquivalent(opening.tagName, lastChild.closingElement.tagName)) {
|
|
const end = lastChild.children.end;
|
|
const newLast = finishNode(
|
|
factory2.createJsxElement(
|
|
lastChild.openingElement,
|
|
lastChild.children,
|
|
finishNode(factory2.createJsxClosingElement(finishNode(factory2.createIdentifier(""), end, end)), end, end)
|
|
),
|
|
lastChild.openingElement.pos,
|
|
end
|
|
);
|
|
children = createNodeArray([...children.slice(0, children.length - 1), newLast], children.pos, end);
|
|
closingElement = lastChild.closingElement;
|
|
} else {
|
|
closingElement = parseJsxClosingElement(opening, inExpressionContext);
|
|
if (!tagNamesAreEquivalent(opening.tagName, closingElement.tagName)) {
|
|
if (openingTag && isJsxOpeningElement(openingTag) && tagNamesAreEquivalent(closingElement.tagName, openingTag.tagName)) {
|
|
parseErrorAtRange(opening.tagName, Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, getTextOfNodeFromSourceText(sourceText, opening.tagName));
|
|
} else {
|
|
parseErrorAtRange(closingElement.tagName, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, getTextOfNodeFromSourceText(sourceText, opening.tagName));
|
|
}
|
|
}
|
|
}
|
|
result = finishNode(factory2.createJsxElement(opening, children, closingElement), pos);
|
|
} else if (opening.kind === 286 /* JsxOpeningFragment */) {
|
|
result = finishNode(factory2.createJsxFragment(opening, parseJsxChildren(opening), parseJsxClosingFragment(inExpressionContext)), pos);
|
|
} else {
|
|
Debug.assert(opening.kind === 282 /* JsxSelfClosingElement */);
|
|
result = opening;
|
|
}
|
|
if (inExpressionContext && token() === 29 /* LessThanToken */) {
|
|
const topBadPos = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition;
|
|
const invalidElement = tryParse(() => parseJsxElementOrSelfClosingElementOrFragment(true, topBadPos));
|
|
if (invalidElement) {
|
|
const operatorToken = createMissingNode(27 /* CommaToken */, false);
|
|
setTextRangePosWidth(operatorToken, invalidElement.pos, 0);
|
|
parseErrorAt(skipTrivia(sourceText, topBadPos), invalidElement.end, Diagnostics.JSX_expressions_must_have_one_parent_element);
|
|
return finishNode(factory2.createBinaryExpression(result, operatorToken, invalidElement), pos);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function parseJsxText() {
|
|
const pos = getNodePos();
|
|
const node = factory2.createJsxText(scanner.getTokenValue(), currentToken === 12 /* JsxTextAllWhiteSpaces */);
|
|
currentToken = scanner.scanJsxToken();
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseJsxChild(openingTag, token2) {
|
|
switch (token2) {
|
|
case 1 /* EndOfFileToken */:
|
|
if (isJsxOpeningFragment(openingTag)) {
|
|
parseErrorAtRange(openingTag, Diagnostics.JSX_fragment_has_no_corresponding_closing_tag);
|
|
} else {
|
|
const tag = openingTag.tagName;
|
|
const start = skipTrivia(sourceText, tag.pos);
|
|
parseErrorAt(start, tag.end, Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, getTextOfNodeFromSourceText(sourceText, openingTag.tagName));
|
|
}
|
|
return void 0;
|
|
case 30 /* LessThanSlashToken */:
|
|
case 7 /* ConflictMarkerTrivia */:
|
|
return void 0;
|
|
case 11 /* JsxText */:
|
|
case 12 /* JsxTextAllWhiteSpaces */:
|
|
return parseJsxText();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseJsxExpression(false);
|
|
case 29 /* LessThanToken */:
|
|
return parseJsxElementOrSelfClosingElementOrFragment(false, void 0, openingTag);
|
|
default:
|
|
return Debug.assertNever(token2);
|
|
}
|
|
}
|
|
function parseJsxChildren(openingTag) {
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << ParsingContext.JsxChildren;
|
|
while (true) {
|
|
const child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken());
|
|
if (!child)
|
|
break;
|
|
list.push(child);
|
|
if (isJsxOpeningElement(openingTag) && (child == null ? void 0 : child.kind) === 281 /* JsxElement */ && !tagNamesAreEquivalent(child.openingElement.tagName, child.closingElement.tagName) && tagNamesAreEquivalent(openingTag.tagName, child.closingElement.tagName)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray(list, listPos);
|
|
}
|
|
function parseJsxAttributes() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createJsxAttributes(parseList(ParsingContext.JsxAttributes, parseJsxAttribute)), pos);
|
|
}
|
|
function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(29 /* LessThanToken */);
|
|
if (token() === 31 /* GreaterThanToken */) {
|
|
scanJsxText();
|
|
return finishNode(factory2.createJsxOpeningFragment(), pos);
|
|
}
|
|
const tagName = parseJsxElementName();
|
|
const typeArguments = (contextFlags & 262144 /* JavaScriptFile */) === 0 ? tryParseTypeArguments() : void 0;
|
|
const attributes = parseJsxAttributes();
|
|
let node;
|
|
if (token() === 31 /* GreaterThanToken */) {
|
|
scanJsxText();
|
|
node = factory2.createJsxOpeningElement(tagName, typeArguments, attributes);
|
|
} else {
|
|
parseExpected(43 /* SlashToken */);
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
node = factory2.createJsxSelfClosingElement(tagName, typeArguments, attributes);
|
|
}
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseJsxElementName() {
|
|
const pos = getNodePos();
|
|
scanJsxIdentifier();
|
|
let expression = token() === 108 /* ThisKeyword */ ? parseTokenNode() : parseIdentifierName();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
expression = finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(true, false)), pos);
|
|
}
|
|
return expression;
|
|
}
|
|
function parseJsxExpression(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
if (!parseExpected(18 /* OpenBraceToken */)) {
|
|
return void 0;
|
|
}
|
|
let dotDotDotToken;
|
|
let expression;
|
|
if (token() !== 19 /* CloseBraceToken */) {
|
|
dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
expression = parseExpression();
|
|
}
|
|
if (inExpressionContext) {
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
if (parseExpected(19 /* CloseBraceToken */, void 0, false)) {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxExpression(dotDotDotToken, expression), pos);
|
|
}
|
|
function parseJsxAttribute() {
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseJsxSpreadAttribute();
|
|
}
|
|
scanJsxIdentifier();
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createJsxAttribute(parseIdentifierName(), parseJsxAttributeValue()), pos);
|
|
}
|
|
function parseJsxAttributeValue() {
|
|
if (token() === 63 /* EqualsToken */) {
|
|
if (scanJsxAttributeValue() === 10 /* StringLiteral */) {
|
|
return parseLiteralNode();
|
|
}
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseJsxExpression(true);
|
|
}
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return parseJsxElementOrSelfClosingElementOrFragment(true);
|
|
}
|
|
parseErrorAtCurrentToken(Diagnostics.or_JSX_element_expected);
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseJsxSpreadAttribute() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
parseExpected(25 /* DotDotDotToken */);
|
|
const expression = parseExpression();
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createJsxSpreadAttribute(expression), pos);
|
|
}
|
|
function parseJsxClosingElement(open, inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(30 /* LessThanSlashToken */);
|
|
const tagName = parseJsxElementName();
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext || !tagNamesAreEquivalent(open.tagName, tagName)) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxClosingElement(tagName), pos);
|
|
}
|
|
function parseJsxClosingFragment(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(30 /* LessThanSlashToken */);
|
|
if (tokenIsIdentifierOrKeyword(token())) {
|
|
parseErrorAtRange(parseJsxElementName(), Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment);
|
|
}
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxJsxClosingFragment(), pos);
|
|
}
|
|
function parseTypeAssertion() {
|
|
const pos = getNodePos();
|
|
parseExpected(29 /* LessThanToken */);
|
|
const type = parseType();
|
|
parseExpected(31 /* GreaterThanToken */);
|
|
const expression = parseSimpleUnaryExpression();
|
|
return finishNode(factory2.createTypeAssertion(type, expression), pos);
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 22 /* OpenBracketToken */ || isTemplateStartOfTaggedTemplate();
|
|
}
|
|
function isStartOfOptionalPropertyOrElementAccessChain() {
|
|
return token() === 28 /* QuestionDotToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate);
|
|
}
|
|
function tryReparseOptionalChain(node) {
|
|
if (node.flags & 32 /* OptionalChain */) {
|
|
return true;
|
|
}
|
|
if (isNonNullExpression(node)) {
|
|
let expr = node.expression;
|
|
while (isNonNullExpression(expr) && !(expr.flags & 32 /* OptionalChain */)) {
|
|
expr = expr.expression;
|
|
}
|
|
if (expr.flags & 32 /* OptionalChain */) {
|
|
while (isNonNullExpression(node)) {
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node = node.expression;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parsePropertyAccessExpressionRest(pos, expression, questionDotToken) {
|
|
const name = parseRightSideOfDot(true, true);
|
|
const isOptionalChain2 = questionDotToken || tryReparseOptionalChain(expression);
|
|
const propertyAccess = isOptionalChain2 ? factory2.createPropertyAccessChain(expression, questionDotToken, name) : factory2.createPropertyAccessExpression(expression, name);
|
|
if (isOptionalChain2 && isPrivateIdentifier(propertyAccess.name)) {
|
|
parseErrorAtRange(propertyAccess.name, Diagnostics.An_optional_chain_cannot_contain_private_identifiers);
|
|
}
|
|
if (isExpressionWithTypeArguments(expression) && expression.typeArguments) {
|
|
const pos2 = expression.typeArguments.pos - 1;
|
|
const end = skipTrivia(sourceText, expression.typeArguments.end) + 1;
|
|
parseErrorAt(pos2, end, Diagnostics.An_instantiation_expression_cannot_be_followed_by_a_property_access);
|
|
}
|
|
return finishNode(propertyAccess, pos);
|
|
}
|
|
function parseElementAccessExpressionRest(pos, expression, questionDotToken) {
|
|
let argumentExpression;
|
|
if (token() === 23 /* CloseBracketToken */) {
|
|
argumentExpression = createMissingNode(79 /* Identifier */, true, Diagnostics.An_element_access_expression_should_take_an_argument);
|
|
} else {
|
|
const argument = allowInAnd(parseExpression);
|
|
if (isStringOrNumericLiteralLike(argument)) {
|
|
argument.text = internIdentifier(argument.text);
|
|
}
|
|
argumentExpression = argument;
|
|
}
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
const indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createElementAccessChain(expression, questionDotToken, argumentExpression) : factory2.createElementAccessExpression(expression, argumentExpression);
|
|
return finishNode(indexedAccess, pos);
|
|
}
|
|
function parseMemberExpressionRest(pos, expression, allowOptionalChain) {
|
|
while (true) {
|
|
let questionDotToken;
|
|
let isPropertyAccess = false;
|
|
if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) {
|
|
questionDotToken = parseExpectedToken(28 /* QuestionDotToken */);
|
|
isPropertyAccess = tokenIsIdentifierOrKeyword(token());
|
|
} else {
|
|
isPropertyAccess = parseOptional(24 /* DotToken */);
|
|
}
|
|
if (isPropertyAccess) {
|
|
expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
|
|
continue;
|
|
}
|
|
if ((questionDotToken || !inDecoratorContext()) && parseOptional(22 /* OpenBracketToken */)) {
|
|
expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
|
|
continue;
|
|
}
|
|
if (isTemplateStartOfTaggedTemplate()) {
|
|
expression = !questionDotToken && expression.kind === 230 /* ExpressionWithTypeArguments */ ? parseTaggedTemplateRest(pos, expression.expression, questionDotToken, expression.typeArguments) : parseTaggedTemplateRest(pos, expression, questionDotToken, void 0);
|
|
continue;
|
|
}
|
|
if (!questionDotToken) {
|
|
if (token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
expression = finishNode(factory2.createNonNullExpression(expression), pos);
|
|
continue;
|
|
}
|
|
const typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (typeArguments) {
|
|
expression = finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
|
|
continue;
|
|
}
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
function isTemplateStartOfTaggedTemplate() {
|
|
return token() === 14 /* NoSubstitutionTemplateLiteral */ || token() === 15 /* TemplateHead */;
|
|
}
|
|
function parseTaggedTemplateRest(pos, tag, questionDotToken, typeArguments) {
|
|
const tagExpression = factory2.createTaggedTemplateExpression(
|
|
tag,
|
|
typeArguments,
|
|
token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : parseTemplateExpression(true)
|
|
);
|
|
if (questionDotToken || tag.flags & 32 /* OptionalChain */) {
|
|
tagExpression.flags |= 32 /* OptionalChain */;
|
|
}
|
|
tagExpression.questionDotToken = questionDotToken;
|
|
return finishNode(tagExpression, pos);
|
|
}
|
|
function parseCallExpressionRest(pos, expression) {
|
|
while (true) {
|
|
expression = parseMemberExpressionRest(pos, expression, true);
|
|
let typeArguments;
|
|
const questionDotToken = parseOptionalToken(28 /* QuestionDotToken */);
|
|
if (questionDotToken) {
|
|
typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (isTemplateStartOfTaggedTemplate()) {
|
|
expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
|
|
continue;
|
|
}
|
|
}
|
|
if (typeArguments || token() === 20 /* OpenParenToken */) {
|
|
if (!questionDotToken && expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
typeArguments = expression.typeArguments;
|
|
expression = expression.expression;
|
|
}
|
|
const argumentList = parseArgumentList();
|
|
const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createCallChain(expression, questionDotToken, typeArguments, argumentList) : factory2.createCallExpression(expression, typeArguments, argumentList);
|
|
expression = finishNode(callExpr, pos);
|
|
continue;
|
|
}
|
|
if (questionDotToken) {
|
|
const name = createMissingNode(79 /* Identifier */, false, Diagnostics.Identifier_expected);
|
|
expression = finishNode(factory2.createPropertyAccessChain(expression, questionDotToken, name), pos);
|
|
}
|
|
break;
|
|
}
|
|
return expression;
|
|
}
|
|
function parseArgumentList() {
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return result;
|
|
}
|
|
function parseTypeArgumentsInExpression() {
|
|
if ((contextFlags & 262144 /* JavaScriptFile */) !== 0) {
|
|
return void 0;
|
|
}
|
|
if (reScanLessThanToken() !== 29 /* LessThanToken */) {
|
|
return void 0;
|
|
}
|
|
nextToken();
|
|
const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
|
|
if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
|
|
return void 0;
|
|
}
|
|
nextToken();
|
|
return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : void 0;
|
|
}
|
|
function canFollowTypeArgumentsInExpression() {
|
|
switch (token()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
return true;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
return false;
|
|
}
|
|
return scanner.hasPrecedingLineBreak() || isBinaryOperator2() || !isStartOfExpression();
|
|
}
|
|
function parsePrimaryExpression() {
|
|
switch (token()) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return parseLiteralNode();
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
return parseTokenNode();
|
|
case 20 /* OpenParenToken */:
|
|
return parseParenthesizedExpression();
|
|
case 22 /* OpenBracketToken */:
|
|
return parseArrayLiteralExpression();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseObjectLiteralExpression();
|
|
case 132 /* AsyncKeyword */:
|
|
if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
|
|
break;
|
|
}
|
|
return parseFunctionExpression();
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassExpression();
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionExpression();
|
|
case 103 /* NewKeyword */:
|
|
return parseNewExpressionOrNewDotTarget();
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
if (reScanSlashToken() === 13 /* RegularExpressionLiteral */) {
|
|
return parseLiteralNode();
|
|
}
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
return parseTemplateExpression(false);
|
|
case 80 /* PrivateIdentifier */:
|
|
return parsePrivateIdentifier();
|
|
}
|
|
return parseIdentifier(Diagnostics.Expression_expected);
|
|
}
|
|
function parseParenthesizedExpression() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return withJSDoc(finishNode(factory2.createParenthesizedExpression(expression), pos), hasJSDoc);
|
|
}
|
|
function parseSpreadElement() {
|
|
const pos = getNodePos();
|
|
parseExpected(25 /* DotDotDotToken */);
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
return finishNode(factory2.createSpreadElement(expression), pos);
|
|
}
|
|
function parseArgumentOrArrayLiteralElement() {
|
|
return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() : token() === 27 /* CommaToken */ ? finishNode(factory2.createOmittedExpression(), getNodePos()) : parseAssignmentExpressionOrHigher(true);
|
|
}
|
|
function parseArgumentExpression() {
|
|
return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
|
|
}
|
|
function parseArrayLiteralExpression() {
|
|
const pos = getNodePos();
|
|
const openBracketPosition = scanner.getTokenPos();
|
|
const openBracketParsed = parseExpected(22 /* OpenBracketToken */);
|
|
const multiLine = scanner.hasPrecedingLineBreak();
|
|
const elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement);
|
|
parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketParsed, openBracketPosition);
|
|
return finishNode(factory2.createArrayLiteralExpression(elements, multiLine), pos);
|
|
}
|
|
function parseObjectLiteralElement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (parseOptionalToken(25 /* DotDotDotToken */)) {
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
return withJSDoc(finishNode(factory2.createSpreadAssignment(expression), pos), hasJSDoc);
|
|
}
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers();
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* GetAccessor */, 0 /* None */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SetAccessor */, 0 /* None */);
|
|
}
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const tokenIsIdentifier = isIdentifier2();
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
const exclamationToken = parseOptionalToken(53 /* ExclamationToken */);
|
|
if (asteriskToken || token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken);
|
|
}
|
|
let node;
|
|
const isShorthandPropertyAssignment2 = tokenIsIdentifier && token() !== 58 /* ColonToken */;
|
|
if (isShorthandPropertyAssignment2) {
|
|
const equalsToken = parseOptionalToken(63 /* EqualsToken */);
|
|
const objectAssignmentInitializer = equalsToken ? allowInAnd(() => parseAssignmentExpressionOrHigher(true)) : void 0;
|
|
node = factory2.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
|
|
node.equalsToken = equalsToken;
|
|
} else {
|
|
parseExpected(58 /* ColonToken */);
|
|
const initializer = allowInAnd(() => parseAssignmentExpressionOrHigher(true));
|
|
node = factory2.createPropertyAssignment(name, initializer);
|
|
}
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
node.questionToken = questionToken;
|
|
node.exclamationToken = exclamationToken;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseObjectLiteralExpression() {
|
|
const pos = getNodePos();
|
|
const openBracePosition = scanner.getTokenPos();
|
|
const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
|
|
const multiLine = scanner.hasPrecedingLineBreak();
|
|
const properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralElement, true);
|
|
parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
|
|
return finishNode(factory2.createObjectLiteralExpression(properties, multiLine), pos);
|
|
}
|
|
function parseFunctionExpression() {
|
|
const savedDecoratorContext = inDecoratorContext();
|
|
setDecoratorContext(false);
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiers();
|
|
parseExpected(98 /* FunctionKeyword */);
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalBindingIdentifier) : isGenerator ? doInYieldContext(parseOptionalBindingIdentifier) : isAsync ? doInAwaitContext(parseOptionalBindingIdentifier) : parseOptionalBindingIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlock(isGenerator | isAsync);
|
|
setDecoratorContext(savedDecoratorContext);
|
|
const node = factory2.createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseOptionalBindingIdentifier() {
|
|
return isBindingIdentifier() ? parseBindingIdentifier() : void 0;
|
|
}
|
|
function parseNewExpressionOrNewDotTarget() {
|
|
const pos = getNodePos();
|
|
parseExpected(103 /* NewKeyword */);
|
|
if (parseOptional(24 /* DotToken */)) {
|
|
const name = parseIdentifierName();
|
|
return finishNode(factory2.createMetaProperty(103 /* NewKeyword */, name), pos);
|
|
}
|
|
const expressionPos = getNodePos();
|
|
let expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), false);
|
|
let typeArguments;
|
|
if (expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
typeArguments = expression.typeArguments;
|
|
expression = expression.expression;
|
|
}
|
|
if (token() === 28 /* QuestionDotToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0, getTextOfNodeFromSourceText(sourceText, expression));
|
|
}
|
|
const argumentList = token() === 20 /* OpenParenToken */ ? parseArgumentList() : void 0;
|
|
return finishNode(factory2.createNewExpression(expression, typeArguments, argumentList), pos);
|
|
}
|
|
function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const openBracePosition = scanner.getTokenPos();
|
|
const openBraceParsed = parseExpected(18 /* OpenBraceToken */, diagnosticMessage);
|
|
if (openBraceParsed || ignoreMissingOpenBrace) {
|
|
const multiLine = scanner.hasPrecedingLineBreak();
|
|
const statements = parseList(ParsingContext.BlockStatements, parseStatement);
|
|
parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
|
|
const result = withJSDoc(finishNode(factory2.createBlock(statements, multiLine), pos), hasJSDoc);
|
|
if (token() === 63 /* EqualsToken */) {
|
|
parseErrorAtCurrentToken(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 {
|
|
const statements = createMissingList();
|
|
return withJSDoc(finishNode(factory2.createBlock(statements, void 0), pos), hasJSDoc);
|
|
}
|
|
}
|
|
function parseFunctionBlock(flags, diagnosticMessage) {
|
|
const savedYieldContext = inYieldContext();
|
|
setYieldContext(!!(flags & 1 /* Yield */));
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(!!(flags & 2 /* Await */));
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const saveDecoratorContext = inDecoratorContext();
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(false);
|
|
}
|
|
const block = parseBlock(!!(flags & 16 /* IgnoreMissingOpenBrace */), diagnosticMessage);
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(true);
|
|
}
|
|
topLevel = savedTopLevel;
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return block;
|
|
}
|
|
function parseEmptyStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(26 /* SemicolonToken */);
|
|
return withJSDoc(finishNode(factory2.createEmptyStatement(), pos), hasJSDoc);
|
|
}
|
|
function parseIfStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(99 /* IfKeyword */);
|
|
const openParenPosition = scanner.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const thenStatement = parseStatement();
|
|
const elseStatement = parseOptional(91 /* ElseKeyword */) ? parseStatement() : void 0;
|
|
return withJSDoc(finishNode(factory2.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
|
|
}
|
|
function parseDoStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(90 /* DoKeyword */);
|
|
const statement = parseStatement();
|
|
parseExpected(115 /* WhileKeyword */);
|
|
const openParenPosition = scanner.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
parseOptional(26 /* SemicolonToken */);
|
|
return withJSDoc(finishNode(factory2.createDoStatement(statement, expression), pos), hasJSDoc);
|
|
}
|
|
function parseWhileStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(115 /* WhileKeyword */);
|
|
const openParenPosition = scanner.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const statement = parseStatement();
|
|
return withJSDoc(finishNode(factory2.createWhileStatement(expression, statement), pos), hasJSDoc);
|
|
}
|
|
function parseForOrForInOrForOfStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(97 /* ForKeyword */);
|
|
const awaitToken = parseOptionalToken(133 /* AwaitKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
let initializer;
|
|
if (token() !== 26 /* SemicolonToken */) {
|
|
if (token() === 113 /* VarKeyword */ || token() === 119 /* LetKeyword */ || token() === 85 /* ConstKeyword */) {
|
|
initializer = parseVariableDeclarationList(true);
|
|
} else {
|
|
initializer = disallowInAnd(parseExpression);
|
|
}
|
|
}
|
|
let node;
|
|
if (awaitToken ? parseExpected(162 /* OfKeyword */) : parseOptional(162 /* OfKeyword */)) {
|
|
const expression = allowInAnd(() => parseAssignmentExpressionOrHigher(true));
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForOfStatement(awaitToken, initializer, expression, parseStatement());
|
|
} else if (parseOptional(101 /* InKeyword */)) {
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForInStatement(initializer, expression, parseStatement());
|
|
} else {
|
|
parseExpected(26 /* SemicolonToken */);
|
|
const condition = token() !== 26 /* SemicolonToken */ && token() !== 21 /* CloseParenToken */ ? allowInAnd(parseExpression) : void 0;
|
|
parseExpected(26 /* SemicolonToken */);
|
|
const incrementor = token() !== 21 /* CloseParenToken */ ? allowInAnd(parseExpression) : void 0;
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForStatement(initializer, condition, incrementor, parseStatement());
|
|
}
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseBreakOrContinueStatement(kind) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(kind === 249 /* BreakStatement */ ? 81 /* BreakKeyword */ : 86 /* ContinueKeyword */);
|
|
const label = canParseSemicolon() ? void 0 : parseIdentifier();
|
|
parseSemicolon();
|
|
const node = kind === 249 /* BreakStatement */ ? factory2.createBreakStatement(label) : factory2.createContinueStatement(label);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseReturnStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(105 /* ReturnKeyword */);
|
|
const expression = canParseSemicolon() ? void 0 : allowInAnd(parseExpression);
|
|
parseSemicolon();
|
|
return withJSDoc(finishNode(factory2.createReturnStatement(expression), pos), hasJSDoc);
|
|
}
|
|
function parseWithStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(116 /* WithKeyword */);
|
|
const openParenPosition = scanner.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const statement = doInsideOfContext(33554432 /* InWithStatement */, parseStatement);
|
|
return withJSDoc(finishNode(factory2.createWithStatement(expression, statement), pos), hasJSDoc);
|
|
}
|
|
function parseCaseClause() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(82 /* CaseKeyword */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(58 /* ColonToken */);
|
|
const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
|
|
return withJSDoc(finishNode(factory2.createCaseClause(expression, statements), pos), hasJSDoc);
|
|
}
|
|
function parseDefaultClause() {
|
|
const pos = getNodePos();
|
|
parseExpected(88 /* DefaultKeyword */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
|
|
return finishNode(factory2.createDefaultClause(statements), pos);
|
|
}
|
|
function parseCaseOrDefaultClause() {
|
|
return token() === 82 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause();
|
|
}
|
|
function parseCaseBlock() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const clauses = parseList(ParsingContext.SwitchClauses, parseCaseOrDefaultClause);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createCaseBlock(clauses), pos);
|
|
}
|
|
function parseSwitchStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(107 /* SwitchKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
const caseBlock = parseCaseBlock();
|
|
return withJSDoc(finishNode(factory2.createSwitchStatement(expression, caseBlock), pos), hasJSDoc);
|
|
}
|
|
function parseThrowStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(109 /* ThrowKeyword */);
|
|
let expression = scanner.hasPrecedingLineBreak() ? void 0 : allowInAnd(parseExpression);
|
|
if (expression === void 0) {
|
|
identifierCount++;
|
|
expression = finishNode(factory2.createIdentifier(""), getNodePos());
|
|
}
|
|
if (!tryParseSemicolon()) {
|
|
parseErrorForMissingSemicolonAfter(expression);
|
|
}
|
|
return withJSDoc(finishNode(factory2.createThrowStatement(expression), pos), hasJSDoc);
|
|
}
|
|
function parseTryStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(111 /* TryKeyword */);
|
|
const tryBlock = parseBlock(false);
|
|
const catchClause = token() === 83 /* CatchKeyword */ ? parseCatchClause() : void 0;
|
|
let finallyBlock;
|
|
if (!catchClause || token() === 96 /* FinallyKeyword */) {
|
|
parseExpected(96 /* FinallyKeyword */, Diagnostics.catch_or_finally_expected);
|
|
finallyBlock = parseBlock(false);
|
|
}
|
|
return withJSDoc(finishNode(factory2.createTryStatement(tryBlock, catchClause, finallyBlock), pos), hasJSDoc);
|
|
}
|
|
function parseCatchClause() {
|
|
const pos = getNodePos();
|
|
parseExpected(83 /* CatchKeyword */);
|
|
let variableDeclaration;
|
|
if (parseOptional(20 /* OpenParenToken */)) {
|
|
variableDeclaration = parseVariableDeclaration();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
} else {
|
|
variableDeclaration = void 0;
|
|
}
|
|
const block = parseBlock(false);
|
|
return finishNode(factory2.createCatchClause(variableDeclaration, block), pos);
|
|
}
|
|
function parseDebuggerStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(87 /* DebuggerKeyword */);
|
|
parseSemicolon();
|
|
return withJSDoc(finishNode(factory2.createDebuggerStatement(), pos), hasJSDoc);
|
|
}
|
|
function parseExpressionOrLabeledStatement() {
|
|
const pos = getNodePos();
|
|
let hasJSDoc = hasPrecedingJSDocComment();
|
|
let node;
|
|
const hasParen = token() === 20 /* OpenParenToken */;
|
|
const expression = allowInAnd(parseExpression);
|
|
if (isIdentifier(expression) && parseOptional(58 /* ColonToken */)) {
|
|
node = factory2.createLabeledStatement(expression, parseStatement());
|
|
} else {
|
|
if (!tryParseSemicolon()) {
|
|
parseErrorForMissingSemicolonAfter(expression);
|
|
}
|
|
node = factory2.createExpressionStatement(expression);
|
|
if (hasParen) {
|
|
hasJSDoc = false;
|
|
}
|
|
}
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOnSameLine() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsClassKeywordOnSameLine() {
|
|
nextToken();
|
|
return token() === 84 /* ClassKeyword */ && !scanner.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsFunctionKeywordOnSameLine() {
|
|
nextToken();
|
|
return token() === 98 /* FunctionKeyword */ && !scanner.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() {
|
|
nextToken();
|
|
return (tokenIsIdentifierOrKeyword(token()) || token() === 8 /* NumericLiteral */ || token() === 9 /* BigIntLiteral */ || token() === 10 /* StringLiteral */) && !scanner.hasPrecedingLineBreak();
|
|
}
|
|
function isDeclaration2() {
|
|
while (true) {
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
return true;
|
|
case 118 /* InterfaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
return nextTokenIsIdentifierOnSameLine();
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
return nextTokenIsIdentifierOrStringLiteralOnSameLine();
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 132 /* AsyncKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
nextToken();
|
|
if (scanner.hasPrecedingLineBreak()) {
|
|
return false;
|
|
}
|
|
continue;
|
|
case 159 /* GlobalKeyword */:
|
|
nextToken();
|
|
return token() === 18 /* OpenBraceToken */ || token() === 79 /* Identifier */ || token() === 93 /* ExportKeyword */;
|
|
case 100 /* ImportKeyword */:
|
|
nextToken();
|
|
return token() === 10 /* StringLiteral */ || token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */ || tokenIsIdentifierOrKeyword(token());
|
|
case 93 /* ExportKeyword */:
|
|
let currentToken2 = nextToken();
|
|
if (currentToken2 === 154 /* TypeKeyword */) {
|
|
currentToken2 = lookAhead(nextToken);
|
|
}
|
|
if (currentToken2 === 63 /* EqualsToken */ || currentToken2 === 41 /* AsteriskToken */ || currentToken2 === 18 /* OpenBraceToken */ || currentToken2 === 88 /* DefaultKeyword */ || currentToken2 === 128 /* AsKeyword */) {
|
|
return true;
|
|
}
|
|
continue;
|
|
case 124 /* StaticKeyword */:
|
|
nextToken();
|
|
continue;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function isStartOfDeclaration() {
|
|
return lookAhead(isDeclaration2);
|
|
}
|
|
function isStartOfStatement() {
|
|
switch (token()) {
|
|
case 59 /* AtToken */:
|
|
case 26 /* SemicolonToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 99 /* IfKeyword */:
|
|
case 90 /* DoKeyword */:
|
|
case 115 /* WhileKeyword */:
|
|
case 97 /* ForKeyword */:
|
|
case 86 /* ContinueKeyword */:
|
|
case 81 /* BreakKeyword */:
|
|
case 105 /* ReturnKeyword */:
|
|
case 116 /* WithKeyword */:
|
|
case 107 /* SwitchKeyword */:
|
|
case 109 /* ThrowKeyword */:
|
|
case 111 /* TryKeyword */:
|
|
case 87 /* DebuggerKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
return true;
|
|
case 100 /* ImportKeyword */:
|
|
return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
|
|
case 85 /* ConstKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
return isStartOfDeclaration();
|
|
case 132 /* AsyncKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
case 159 /* GlobalKeyword */:
|
|
return true;
|
|
case 127 /* AccessorKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
|
|
default:
|
|
return isStartOfExpression();
|
|
}
|
|
}
|
|
function nextTokenIsBindingIdentifierOrStartOfDestructuring() {
|
|
nextToken();
|
|
return isBindingIdentifier() || token() === 18 /* OpenBraceToken */ || token() === 22 /* OpenBracketToken */;
|
|
}
|
|
function isLetDeclaration() {
|
|
return lookAhead(nextTokenIsBindingIdentifierOrStartOfDestructuring);
|
|
}
|
|
function parseStatement() {
|
|
switch (token()) {
|
|
case 26 /* SemicolonToken */:
|
|
return parseEmptyStatement();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseBlock(false);
|
|
case 113 /* VarKeyword */:
|
|
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 119 /* LetKeyword */:
|
|
if (isLetDeclaration()) {
|
|
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
}
|
|
break;
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionDeclaration(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassDeclaration(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 99 /* IfKeyword */:
|
|
return parseIfStatement();
|
|
case 90 /* DoKeyword */:
|
|
return parseDoStatement();
|
|
case 115 /* WhileKeyword */:
|
|
return parseWhileStatement();
|
|
case 97 /* ForKeyword */:
|
|
return parseForOrForInOrForOfStatement();
|
|
case 86 /* ContinueKeyword */:
|
|
return parseBreakOrContinueStatement(248 /* ContinueStatement */);
|
|
case 81 /* BreakKeyword */:
|
|
return parseBreakOrContinueStatement(249 /* BreakStatement */);
|
|
case 105 /* ReturnKeyword */:
|
|
return parseReturnStatement();
|
|
case 116 /* WithKeyword */:
|
|
return parseWithStatement();
|
|
case 107 /* SwitchKeyword */:
|
|
return parseSwitchStatement();
|
|
case 109 /* ThrowKeyword */:
|
|
return parseThrowStatement();
|
|
case 111 /* TryKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
return parseTryStatement();
|
|
case 87 /* DebuggerKeyword */:
|
|
return parseDebuggerStatement();
|
|
case 59 /* AtToken */:
|
|
return parseDeclaration();
|
|
case 132 /* AsyncKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 159 /* GlobalKeyword */:
|
|
if (isStartOfDeclaration()) {
|
|
return parseDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
return parseExpressionOrLabeledStatement();
|
|
}
|
|
function isDeclareModifier(modifier) {
|
|
return modifier.kind === 136 /* DeclareKeyword */;
|
|
}
|
|
function parseDeclaration() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers();
|
|
const isAmbient = some(modifiers, isDeclareModifier);
|
|
if (isAmbient) {
|
|
const node = tryReuseAmbientDeclaration(pos);
|
|
if (node) {
|
|
return node;
|
|
}
|
|
for (const m of modifiers) {
|
|
m.flags |= 16777216 /* Ambient */;
|
|
}
|
|
return doInsideOfContext(16777216 /* Ambient */, () => parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers));
|
|
} else {
|
|
return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
function tryReuseAmbientDeclaration(pos) {
|
|
return doInsideOfContext(16777216 /* Ambient */, () => {
|
|
const node = currentNode(parsingContext, pos);
|
|
if (node) {
|
|
return consumeNode(node);
|
|
}
|
|
});
|
|
}
|
|
function parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers) {
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 118 /* InterfaceKeyword */:
|
|
return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 154 /* TypeKeyword */:
|
|
return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 92 /* EnumKeyword */:
|
|
return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 159 /* GlobalKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 100 /* ImportKeyword */:
|
|
return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 93 /* ExportKeyword */:
|
|
nextToken();
|
|
switch (token()) {
|
|
case 88 /* DefaultKeyword */:
|
|
case 63 /* EqualsToken */:
|
|
return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
|
|
case 128 /* AsKeyword */:
|
|
return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
default:
|
|
return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
default:
|
|
if (decorators || modifiers) {
|
|
const missing = createMissingNode(279 /* MissingDeclaration */, true, Diagnostics.Declaration_expected);
|
|
setTextRangePos(missing, pos);
|
|
missing.illegalDecorators = decorators;
|
|
missing.modifiers = modifiers;
|
|
return missing;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
|
|
nextToken();
|
|
return !scanner.hasPrecedingLineBreak() && (isIdentifier2() || token() === 10 /* StringLiteral */);
|
|
}
|
|
function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
|
|
if (token() !== 18 /* OpenBraceToken */) {
|
|
if (flags & 4 /* Type */) {
|
|
parseTypeMemberSemicolon();
|
|
return;
|
|
}
|
|
if (canParseSemicolon()) {
|
|
parseSemicolon();
|
|
return;
|
|
}
|
|
}
|
|
return parseFunctionBlock(flags, diagnosticMessage);
|
|
}
|
|
function parseArrayBindingElement() {
|
|
const pos = getNodePos();
|
|
if (token() === 27 /* CommaToken */) {
|
|
return finishNode(factory2.createOmittedExpression(), pos);
|
|
}
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const name = parseIdentifierOrPattern();
|
|
const initializer = parseInitializer();
|
|
return finishNode(factory2.createBindingElement(dotDotDotToken, void 0, name, initializer), pos);
|
|
}
|
|
function parseObjectBindingElement() {
|
|
const pos = getNodePos();
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const tokenIsIdentifier = isBindingIdentifier();
|
|
let propertyName = parsePropertyName();
|
|
let name;
|
|
if (tokenIsIdentifier && token() !== 58 /* ColonToken */) {
|
|
name = propertyName;
|
|
propertyName = void 0;
|
|
} else {
|
|
parseExpected(58 /* ColonToken */);
|
|
name = parseIdentifierOrPattern();
|
|
}
|
|
const initializer = parseInitializer();
|
|
return finishNode(factory2.createBindingElement(dotDotDotToken, propertyName, name, initializer), pos);
|
|
}
|
|
function parseObjectBindingPattern() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createObjectBindingPattern(elements), pos);
|
|
}
|
|
function parseArrayBindingPattern() {
|
|
const pos = getNodePos();
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
return finishNode(factory2.createArrayBindingPattern(elements), pos);
|
|
}
|
|
function isBindingIdentifierOrPrivateIdentifierOrPattern() {
|
|
return token() === 18 /* OpenBraceToken */ || token() === 22 /* OpenBracketToken */ || token() === 80 /* PrivateIdentifier */ || isBindingIdentifier();
|
|
}
|
|
function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) {
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return parseArrayBindingPattern();
|
|
}
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseObjectBindingPattern();
|
|
}
|
|
return parseBindingIdentifier(privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseVariableDeclarationAllowExclamation() {
|
|
return parseVariableDeclaration(true);
|
|
}
|
|
function parseVariableDeclaration(allowExclamation) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const name = parseIdentifierOrPattern(Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations);
|
|
let exclamationToken;
|
|
if (allowExclamation && name.kind === 79 /* Identifier */ && token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
|
|
exclamationToken = parseTokenNode();
|
|
}
|
|
const type = parseTypeAnnotation();
|
|
const initializer = isInOrOfKeyword(token()) ? void 0 : parseInitializer();
|
|
const node = factory2.createVariableDeclaration(name, exclamationToken, type, initializer);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseVariableDeclarationList(inForStatementInitializer) {
|
|
const pos = getNodePos();
|
|
let flags = 0;
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
break;
|
|
case 119 /* LetKeyword */:
|
|
flags |= 1 /* Let */;
|
|
break;
|
|
case 85 /* ConstKeyword */:
|
|
flags |= 2 /* Const */;
|
|
break;
|
|
default:
|
|
Debug.fail();
|
|
}
|
|
nextToken();
|
|
let declarations;
|
|
if (token() === 162 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) {
|
|
declarations = createMissingList();
|
|
} else {
|
|
const savedDisallowIn = inDisallowInContext();
|
|
setDisallowInContext(inForStatementInitializer);
|
|
declarations = parseDelimitedList(
|
|
ParsingContext.VariableDeclarations,
|
|
inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
|
|
);
|
|
setDisallowInContext(savedDisallowIn);
|
|
}
|
|
return finishNode(factory2.createVariableDeclarationList(declarations, flags), pos);
|
|
}
|
|
function canFollowContextualOfKeyword() {
|
|
return nextTokenIsIdentifier() && nextToken() === 21 /* CloseParenToken */;
|
|
}
|
|
function parseVariableStatement(pos, hasJSDoc, decorators, modifiers) {
|
|
const declarationList = parseVariableDeclarationList(false);
|
|
parseSemicolon();
|
|
const node = factory2.createVariableStatement(modifiers, declarationList);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
const modifierFlags = modifiersToFlags(modifiers);
|
|
parseExpected(98 /* FunctionKeyword */);
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const name = modifierFlags & 1024 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = modifierFlags & 512 /* Async */ ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
if (modifierFlags & 1 /* Export */)
|
|
setAwaitContext(true);
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, Diagnostics.or_expected);
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseConstructorName() {
|
|
if (token() === 135 /* ConstructorKeyword */) {
|
|
return parseExpected(135 /* ConstructorKeyword */);
|
|
}
|
|
if (token() === 10 /* StringLiteral */ && lookAhead(nextToken) === 20 /* OpenParenToken */) {
|
|
return tryParse(() => {
|
|
const literalNode = parseLiteralNode();
|
|
return literalNode.text === "constructor" ? literalNode : void 0;
|
|
});
|
|
}
|
|
}
|
|
function tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
return tryParse(() => {
|
|
if (parseConstructorName()) {
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(0 /* None */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(0 /* None */, Diagnostics.or_expected);
|
|
const node = factory2.createConstructorDeclaration(modifiers, parameters, body);
|
|
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) {
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);
|
|
const node = factory2.createMethodDeclaration(
|
|
combineDecoratorsAndModifiers(decorators, modifiers),
|
|
asteriskToken,
|
|
name,
|
|
questionToken,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.exclamationToken = exclamationToken;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken) {
|
|
const exclamationToken = !questionToken && !scanner.hasPrecedingLineBreak() ? parseOptionalToken(53 /* ExclamationToken */) : void 0;
|
|
const type = parseTypeAnnotation();
|
|
const initializer = doOutsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */ | 4096 /* DisallowInContext */, parseInitializer);
|
|
parseSemicolonAfterPropertyName(name, type, initializer);
|
|
const node = factory2.createPropertyDeclaration(
|
|
combineDecoratorsAndModifiers(decorators, modifiers),
|
|
name,
|
|
questionToken || exclamationToken,
|
|
type,
|
|
initializer
|
|
);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
if (asteriskToken || token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, void 0, Diagnostics.or_expected);
|
|
}
|
|
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
|
|
}
|
|
function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) {
|
|
const name = parsePropertyName();
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(0 /* None */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(flags);
|
|
const node = kind === 174 /* GetAccessor */ ? factory2.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body) : factory2.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body);
|
|
node.typeParameters = typeParameters;
|
|
if (isSetAccessorDeclaration(node))
|
|
node.type = type;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isClassMemberStart() {
|
|
let idToken;
|
|
if (token() === 59 /* AtToken */) {
|
|
return true;
|
|
}
|
|
while (isModifierKind(token())) {
|
|
idToken = token();
|
|
if (isClassMemberModifier(idToken)) {
|
|
return true;
|
|
}
|
|
nextToken();
|
|
}
|
|
if (token() === 41 /* AsteriskToken */) {
|
|
return true;
|
|
}
|
|
if (isLiteralPropertyName()) {
|
|
idToken = token();
|
|
nextToken();
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return true;
|
|
}
|
|
if (idToken !== void 0) {
|
|
if (!isKeyword(idToken) || idToken === 151 /* SetKeyword */ || idToken === 137 /* GetKeyword */) {
|
|
return true;
|
|
}
|
|
switch (token()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 58 /* ColonToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 57 /* QuestionToken */:
|
|
return true;
|
|
default:
|
|
return canParseSemicolon();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpectedToken(124 /* StaticKeyword */);
|
|
const body = parseClassStaticBlockBody();
|
|
const node = withJSDoc(finishNode(factory2.createClassStaticBlockDeclaration(body), pos), hasJSDoc);
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
return node;
|
|
}
|
|
function parseClassStaticBlockBody() {
|
|
const savedYieldContext = inYieldContext();
|
|
const savedAwaitContext = inAwaitContext();
|
|
setYieldContext(false);
|
|
setAwaitContext(true);
|
|
const body = parseBlock(false);
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return body;
|
|
}
|
|
function parseDecoratorExpression() {
|
|
if (inAwaitContext() && token() === 133 /* AwaitKeyword */) {
|
|
const pos = getNodePos();
|
|
const awaitExpression = parseIdentifier(Diagnostics.Expression_expected);
|
|
nextToken();
|
|
const memberExpression = parseMemberExpressionRest(pos, awaitExpression, true);
|
|
return parseCallExpressionRest(pos, memberExpression);
|
|
}
|
|
return parseLeftHandSideExpressionOrHigher();
|
|
}
|
|
function tryParseDecorator() {
|
|
const pos = getNodePos();
|
|
if (!parseOptional(59 /* AtToken */)) {
|
|
return void 0;
|
|
}
|
|
const expression = doInDecoratorContext(parseDecoratorExpression);
|
|
return finishNode(factory2.createDecorator(expression), pos);
|
|
}
|
|
function parseDecorators() {
|
|
const pos = getNodePos();
|
|
let list, decorator;
|
|
while (decorator = tryParseDecorator()) {
|
|
list = append(list, decorator);
|
|
}
|
|
return list && createNodeArray(list, pos);
|
|
}
|
|
function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
if (token() === 85 /* ConstKeyword */ && permitInvalidConstAsModifier) {
|
|
if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
|
|
return void 0;
|
|
}
|
|
} else if (stopOnStartOfClassStaticBlock && token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
|
|
return void 0;
|
|
} else if (hasSeenStaticModifier && token() === 124 /* StaticKeyword */) {
|
|
return void 0;
|
|
} else {
|
|
if (!parseAnyContextualModifier()) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function combineDecoratorsAndModifiers(decorators, modifiers) {
|
|
if (!decorators)
|
|
return modifiers;
|
|
if (!modifiers)
|
|
return decorators;
|
|
const decoratorsAndModifiers = factory2.createNodeArray(concatenate(decorators, modifiers));
|
|
setTextRangePosEnd(decoratorsAndModifiers, decorators.pos, modifiers.end);
|
|
return decoratorsAndModifiers;
|
|
}
|
|
function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
|
|
const pos = getNodePos();
|
|
let list, modifier, hasSeenStatic = false;
|
|
while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
|
|
if (modifier.kind === 124 /* StaticKeyword */)
|
|
hasSeenStatic = true;
|
|
list = append(list, modifier);
|
|
}
|
|
return list && createNodeArray(list, pos);
|
|
}
|
|
function parseModifiersForArrowFunction() {
|
|
let modifiers;
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
const modifier = finishNode(factory2.createToken(132 /* AsyncKeyword */), pos);
|
|
modifiers = createNodeArray([modifier], pos);
|
|
}
|
|
return modifiers;
|
|
}
|
|
function parseClassElement() {
|
|
const pos = getNodePos();
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
nextToken();
|
|
return finishNode(factory2.createSemicolonClassElement(), pos);
|
|
}
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers(true, true);
|
|
if (token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
|
|
return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* GetAccessor */, 0 /* None */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SetAccessor */, 0 /* None */);
|
|
}
|
|
if (token() === 135 /* ConstructorKeyword */ || token() === 10 /* StringLiteral */) {
|
|
const constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
if (constructorDeclaration) {
|
|
return constructorDeclaration;
|
|
}
|
|
}
|
|
if (isIndexSignature()) {
|
|
return parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
if (tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */ || token() === 41 /* AsteriskToken */ || token() === 22 /* OpenBracketToken */) {
|
|
const isAmbient = some(modifiers, isDeclareModifier);
|
|
if (isAmbient) {
|
|
for (const m of modifiers) {
|
|
m.flags |= 16777216 /* Ambient */;
|
|
}
|
|
return doInsideOfContext(16777216 /* Ambient */, () => parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers));
|
|
} else {
|
|
return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
if (decorators || modifiers) {
|
|
const name = createMissingNode(79 /* Identifier */, true, Diagnostics.Declaration_expected);
|
|
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, void 0);
|
|
}
|
|
return Debug.fail("Should not have attempted to parse class member declaration.");
|
|
}
|
|
function parseClassExpression() {
|
|
return parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0, 228 /* ClassExpression */);
|
|
}
|
|
function parseClassDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, 260 /* ClassDeclaration */);
|
|
}
|
|
function parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, kind) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
parseExpected(84 /* ClassKeyword */);
|
|
const name = parseNameOfClassDeclarationOrExpression();
|
|
const typeParameters = parseTypeParameters();
|
|
if (some(modifiers, isExportModifier))
|
|
setAwaitContext(true);
|
|
const heritageClauses = parseHeritageClauses();
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = parseClassMembers();
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = kind === 260 /* ClassDeclaration */ ? factory2.createClassDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members) : factory2.createClassExpression(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseNameOfClassDeclarationOrExpression() {
|
|
return isBindingIdentifier() && !isImplementsClause() ? createIdentifier(isBindingIdentifier()) : void 0;
|
|
}
|
|
function isImplementsClause() {
|
|
return token() === 117 /* ImplementsKeyword */ && lookAhead(nextTokenIsIdentifierOrKeyword);
|
|
}
|
|
function parseHeritageClauses() {
|
|
if (isHeritageClause2()) {
|
|
return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseHeritageClause() {
|
|
const pos = getNodePos();
|
|
const tok = token();
|
|
Debug.assert(tok === 94 /* ExtendsKeyword */ || tok === 117 /* ImplementsKeyword */);
|
|
nextToken();
|
|
const types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
|
|
return finishNode(factory2.createHeritageClause(tok, types), pos);
|
|
}
|
|
function parseExpressionWithTypeArguments() {
|
|
const pos = getNodePos();
|
|
const expression = parseLeftHandSideExpressionOrHigher();
|
|
if (expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
return expression;
|
|
}
|
|
const typeArguments = tryParseTypeArguments();
|
|
return finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
|
|
}
|
|
function tryParseTypeArguments() {
|
|
return token() === 29 /* LessThanToken */ ? parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
|
|
}
|
|
function isHeritageClause2() {
|
|
return token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
}
|
|
function parseClassMembers() {
|
|
return parseList(ParsingContext.ClassMembers, parseClassElement);
|
|
}
|
|
function parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(118 /* InterfaceKeyword */);
|
|
const name = parseIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
const heritageClauses = parseHeritageClauses();
|
|
const members = parseObjectTypeMembers();
|
|
const node = factory2.createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(154 /* TypeKeyword */);
|
|
const name = parseIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
parseExpected(63 /* EqualsToken */);
|
|
const type = token() === 139 /* IntrinsicKeyword */ && tryParse(parseKeywordAndNoDot) || parseType();
|
|
parseSemicolon();
|
|
const node = factory2.createTypeAliasDeclaration(modifiers, name, typeParameters, type);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseEnumMember() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const name = parsePropertyName();
|
|
const initializer = allowInAnd(parseInitializer);
|
|
return withJSDoc(finishNode(factory2.createEnumMember(name, initializer), pos), hasJSDoc);
|
|
}
|
|
function parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(92 /* EnumKeyword */);
|
|
const name = parseIdentifier();
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember));
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
const node = factory2.createEnumDeclaration(modifiers, name, members);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseModuleBlock() {
|
|
const pos = getNodePos();
|
|
let statements;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
statements = parseList(ParsingContext.BlockStatements, parseStatement);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
statements = createMissingList();
|
|
}
|
|
return finishNode(factory2.createModuleBlock(statements), pos);
|
|
}
|
|
function parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags) {
|
|
const namespaceFlag = flags & 16 /* Namespace */;
|
|
const name = parseIdentifier();
|
|
const body = parseOptional(24 /* DotToken */) ? parseModuleOrNamespaceDeclaration(getNodePos(), false, void 0, void 0, 4 /* NestedNamespace */ | namespaceFlag) : parseModuleBlock();
|
|
const node = factory2.createModuleDeclaration(modifiers, name, body, flags);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
let flags = 0;
|
|
let name;
|
|
if (token() === 159 /* GlobalKeyword */) {
|
|
name = parseIdentifier();
|
|
flags |= 1024 /* GlobalAugmentation */;
|
|
} else {
|
|
name = parseLiteralNode();
|
|
name.text = internIdentifier(name.text);
|
|
}
|
|
let body;
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
body = parseModuleBlock();
|
|
} else {
|
|
parseSemicolon();
|
|
}
|
|
const node = factory2.createModuleDeclaration(modifiers, name, body, flags);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
let flags = 0;
|
|
if (token() === 159 /* GlobalKeyword */) {
|
|
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
} else if (parseOptional(143 /* NamespaceKeyword */)) {
|
|
flags |= 16 /* Namespace */;
|
|
} else {
|
|
parseExpected(142 /* ModuleKeyword */);
|
|
if (token() === 10 /* StringLiteral */) {
|
|
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags);
|
|
}
|
|
function isExternalModuleReference2() {
|
|
return token() === 147 /* RequireKeyword */ && lookAhead(nextTokenIsOpenParen);
|
|
}
|
|
function nextTokenIsOpenParen() {
|
|
return nextToken() === 20 /* OpenParenToken */;
|
|
}
|
|
function nextTokenIsOpenBrace() {
|
|
return nextToken() === 18 /* OpenBraceToken */;
|
|
}
|
|
function nextTokenIsSlash() {
|
|
return nextToken() === 43 /* SlashToken */;
|
|
}
|
|
function parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(128 /* AsKeyword */);
|
|
parseExpected(143 /* NamespaceKeyword */);
|
|
const name = parseIdentifier();
|
|
parseSemicolon();
|
|
const node = factory2.createNamespaceExportDeclaration(name);
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(100 /* ImportKeyword */);
|
|
const afterImportPos = scanner.getStartPos();
|
|
let identifier;
|
|
if (isIdentifier2()) {
|
|
identifier = parseIdentifier();
|
|
}
|
|
let isTypeOnly = false;
|
|
if (token() !== 158 /* FromKeyword */ && (identifier == null ? void 0 : identifier.escapedText) === "type" && (isIdentifier2() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
|
|
isTypeOnly = true;
|
|
identifier = isIdentifier2() ? parseIdentifier() : void 0;
|
|
}
|
|
if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
|
|
return parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly);
|
|
}
|
|
let importClause;
|
|
if (identifier || token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */) {
|
|
importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
|
|
parseExpected(158 /* FromKeyword */);
|
|
}
|
|
const moduleSpecifier = parseModuleSpecifier();
|
|
let assertClause;
|
|
if (token() === 130 /* AssertKeyword */ && !scanner.hasPrecedingLineBreak()) {
|
|
assertClause = parseAssertClause();
|
|
}
|
|
parseSemicolon();
|
|
const node = factory2.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseAssertEntry() {
|
|
const pos = getNodePos();
|
|
const name = tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const value = parseAssignmentExpressionOrHigher(true);
|
|
return finishNode(factory2.createAssertEntry(name, value), pos);
|
|
}
|
|
function parseAssertClause(skipAssertKeyword) {
|
|
const pos = getNodePos();
|
|
if (!skipAssertKeyword) {
|
|
parseExpected(130 /* AssertKeyword */);
|
|
}
|
|
const openBracePosition = scanner.getTokenPos();
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
const multiLine = scanner.hasPrecedingLineBreak();
|
|
const elements = parseDelimitedList(ParsingContext.AssertEntries, parseAssertEntry, true);
|
|
if (!parseExpected(19 /* CloseBraceToken */)) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
if (lastError && lastError.code === Diagnostics._0_expected.code) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")
|
|
);
|
|
}
|
|
}
|
|
return finishNode(factory2.createAssertClause(elements, multiLine), pos);
|
|
} else {
|
|
const elements = createNodeArray([], getNodePos(), void 0, false);
|
|
return finishNode(factory2.createAssertClause(elements, false), pos);
|
|
}
|
|
}
|
|
function tokenAfterImportDefinitelyProducesImportDeclaration() {
|
|
return token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */;
|
|
}
|
|
function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() {
|
|
return token() === 27 /* CommaToken */ || token() === 158 /* FromKeyword */;
|
|
}
|
|
function parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly) {
|
|
parseExpected(63 /* EqualsToken */);
|
|
const moduleReference = parseModuleReference();
|
|
parseSemicolon();
|
|
const node = factory2.createImportEqualsDeclaration(modifiers, isTypeOnly, identifier, moduleReference);
|
|
node.illegalDecorators = decorators;
|
|
const finished = withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
return finished;
|
|
}
|
|
function parseImportClause(identifier, pos, isTypeOnly) {
|
|
let namedBindings;
|
|
if (!identifier || parseOptional(27 /* CommaToken */)) {
|
|
namedBindings = token() === 41 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(272 /* NamedImports */);
|
|
}
|
|
return finishNode(factory2.createImportClause(isTypeOnly, identifier, namedBindings), pos);
|
|
}
|
|
function parseModuleReference() {
|
|
return isExternalModuleReference2() ? parseExternalModuleReference() : parseEntityName(false);
|
|
}
|
|
function parseExternalModuleReference() {
|
|
const pos = getNodePos();
|
|
parseExpected(147 /* RequireKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = parseModuleSpecifier();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return finishNode(factory2.createExternalModuleReference(expression), pos);
|
|
}
|
|
function parseModuleSpecifier() {
|
|
if (token() === 10 /* StringLiteral */) {
|
|
const result = parseLiteralNode();
|
|
result.text = internIdentifier(result.text);
|
|
return result;
|
|
} else {
|
|
return parseExpression();
|
|
}
|
|
}
|
|
function parseNamespaceImport() {
|
|
const pos = getNodePos();
|
|
parseExpected(41 /* AsteriskToken */);
|
|
parseExpected(128 /* AsKeyword */);
|
|
const name = parseIdentifier();
|
|
return finishNode(factory2.createNamespaceImport(name), pos);
|
|
}
|
|
function parseNamedImportsOrExports(kind) {
|
|
const pos = getNodePos();
|
|
const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseExportSpecifier() {
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
return withJSDoc(parseImportOrExportSpecifier(278 /* ExportSpecifier */), hasJSDoc);
|
|
}
|
|
function parseImportSpecifier() {
|
|
return parseImportOrExportSpecifier(273 /* ImportSpecifier */);
|
|
}
|
|
function parseImportOrExportSpecifier(kind) {
|
|
const pos = getNodePos();
|
|
let checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier2();
|
|
let checkIdentifierStart = scanner.getTokenPos();
|
|
let checkIdentifierEnd = scanner.getTextPos();
|
|
let isTypeOnly = false;
|
|
let propertyName;
|
|
let canParseAsKeyword = true;
|
|
let name = parseIdentifierName();
|
|
if (name.escapedText === "type") {
|
|
if (token() === 128 /* AsKeyword */) {
|
|
const firstAs = parseIdentifierName();
|
|
if (token() === 128 /* AsKeyword */) {
|
|
const secondAs = parseIdentifierName();
|
|
if (tokenIsIdentifierOrKeyword(token())) {
|
|
isTypeOnly = true;
|
|
propertyName = firstAs;
|
|
name = parseNameWithKeywordCheck();
|
|
canParseAsKeyword = false;
|
|
} else {
|
|
propertyName = name;
|
|
name = secondAs;
|
|
canParseAsKeyword = false;
|
|
}
|
|
} else if (tokenIsIdentifierOrKeyword(token())) {
|
|
propertyName = name;
|
|
canParseAsKeyword = false;
|
|
name = parseNameWithKeywordCheck();
|
|
} else {
|
|
isTypeOnly = true;
|
|
name = firstAs;
|
|
}
|
|
} else if (tokenIsIdentifierOrKeyword(token())) {
|
|
isTypeOnly = true;
|
|
name = parseNameWithKeywordCheck();
|
|
}
|
|
}
|
|
if (canParseAsKeyword && token() === 128 /* AsKeyword */) {
|
|
propertyName = name;
|
|
parseExpected(128 /* AsKeyword */);
|
|
name = parseNameWithKeywordCheck();
|
|
}
|
|
if (kind === 273 /* ImportSpecifier */ && checkIdentifierIsKeyword) {
|
|
parseErrorAt(checkIdentifierStart, checkIdentifierEnd, Diagnostics.Identifier_expected);
|
|
}
|
|
const node = kind === 273 /* ImportSpecifier */ ? factory2.createImportSpecifier(isTypeOnly, propertyName, name) : factory2.createExportSpecifier(isTypeOnly, propertyName, name);
|
|
return finishNode(node, pos);
|
|
function parseNameWithKeywordCheck() {
|
|
checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier2();
|
|
checkIdentifierStart = scanner.getTokenPos();
|
|
checkIdentifierEnd = scanner.getTextPos();
|
|
return parseIdentifierName();
|
|
}
|
|
}
|
|
function parseNamespaceExport(pos) {
|
|
return finishNode(factory2.createNamespaceExport(parseIdentifierName()), pos);
|
|
}
|
|
function parseExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(true);
|
|
let exportClause;
|
|
let moduleSpecifier;
|
|
let assertClause;
|
|
const isTypeOnly = parseOptional(154 /* TypeKeyword */);
|
|
const namespaceExportPos = getNodePos();
|
|
if (parseOptional(41 /* AsteriskToken */)) {
|
|
if (parseOptional(128 /* AsKeyword */)) {
|
|
exportClause = parseNamespaceExport(namespaceExportPos);
|
|
}
|
|
parseExpected(158 /* FromKeyword */);
|
|
moduleSpecifier = parseModuleSpecifier();
|
|
} else {
|
|
exportClause = parseNamedImportsOrExports(276 /* NamedExports */);
|
|
if (token() === 158 /* FromKeyword */ || token() === 10 /* StringLiteral */ && !scanner.hasPrecedingLineBreak()) {
|
|
parseExpected(158 /* FromKeyword */);
|
|
moduleSpecifier = parseModuleSpecifier();
|
|
}
|
|
}
|
|
if (moduleSpecifier && token() === 130 /* AssertKeyword */ && !scanner.hasPrecedingLineBreak()) {
|
|
assertClause = parseAssertClause();
|
|
}
|
|
parseSemicolon();
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseExportAssignment(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(true);
|
|
let isExportEquals;
|
|
if (parseOptional(63 /* EqualsToken */)) {
|
|
isExportEquals = true;
|
|
} else {
|
|
parseExpected(88 /* DefaultKeyword */);
|
|
}
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
parseSemicolon();
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createExportAssignment(modifiers, isExportEquals, expression);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
let ParsingContext;
|
|
((ParsingContext2) => {
|
|
ParsingContext2[ParsingContext2["SourceElements"] = 0] = "SourceElements";
|
|
ParsingContext2[ParsingContext2["BlockStatements"] = 1] = "BlockStatements";
|
|
ParsingContext2[ParsingContext2["SwitchClauses"] = 2] = "SwitchClauses";
|
|
ParsingContext2[ParsingContext2["SwitchClauseStatements"] = 3] = "SwitchClauseStatements";
|
|
ParsingContext2[ParsingContext2["TypeMembers"] = 4] = "TypeMembers";
|
|
ParsingContext2[ParsingContext2["ClassMembers"] = 5] = "ClassMembers";
|
|
ParsingContext2[ParsingContext2["EnumMembers"] = 6] = "EnumMembers";
|
|
ParsingContext2[ParsingContext2["HeritageClauseElement"] = 7] = "HeritageClauseElement";
|
|
ParsingContext2[ParsingContext2["VariableDeclarations"] = 8] = "VariableDeclarations";
|
|
ParsingContext2[ParsingContext2["ObjectBindingElements"] = 9] = "ObjectBindingElements";
|
|
ParsingContext2[ParsingContext2["ArrayBindingElements"] = 10] = "ArrayBindingElements";
|
|
ParsingContext2[ParsingContext2["ArgumentExpressions"] = 11] = "ArgumentExpressions";
|
|
ParsingContext2[ParsingContext2["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers";
|
|
ParsingContext2[ParsingContext2["JsxAttributes"] = 13] = "JsxAttributes";
|
|
ParsingContext2[ParsingContext2["JsxChildren"] = 14] = "JsxChildren";
|
|
ParsingContext2[ParsingContext2["ArrayLiteralMembers"] = 15] = "ArrayLiteralMembers";
|
|
ParsingContext2[ParsingContext2["Parameters"] = 16] = "Parameters";
|
|
ParsingContext2[ParsingContext2["JSDocParameters"] = 17] = "JSDocParameters";
|
|
ParsingContext2[ParsingContext2["RestProperties"] = 18] = "RestProperties";
|
|
ParsingContext2[ParsingContext2["TypeParameters"] = 19] = "TypeParameters";
|
|
ParsingContext2[ParsingContext2["TypeArguments"] = 20] = "TypeArguments";
|
|
ParsingContext2[ParsingContext2["TupleElementTypes"] = 21] = "TupleElementTypes";
|
|
ParsingContext2[ParsingContext2["HeritageClauses"] = 22] = "HeritageClauses";
|
|
ParsingContext2[ParsingContext2["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers";
|
|
ParsingContext2[ParsingContext2["AssertEntries"] = 24] = "AssertEntries";
|
|
ParsingContext2[ParsingContext2["Count"] = 25] = "Count";
|
|
})(ParsingContext || (ParsingContext = {}));
|
|
let Tristate;
|
|
((Tristate2) => {
|
|
Tristate2[Tristate2["False"] = 0] = "False";
|
|
Tristate2[Tristate2["True"] = 1] = "True";
|
|
Tristate2[Tristate2["Unknown"] = 2] = "Unknown";
|
|
})(Tristate || (Tristate = {}));
|
|
let JSDocParser;
|
|
((JSDocParser2) => {
|
|
function parseJSDocTypeExpressionForTests(content, start, length2) {
|
|
initializeState("file.js", content, 99 /* Latest */, void 0, 1 /* JS */);
|
|
scanner.setText(content, start, length2);
|
|
currentToken = scanner.scan();
|
|
const jsDocTypeExpression = parseJSDocTypeExpression();
|
|
const sourceFile = createSourceFile2("file.js", 99 /* Latest */, 1 /* JS */, false, [], factory2.createToken(1 /* EndOfFileToken */), 0 /* None */, noop);
|
|
const diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
clearState();
|
|
return jsDocTypeExpression ? { jsDocTypeExpression, diagnostics } : void 0;
|
|
}
|
|
JSDocParser2.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests;
|
|
function parseJSDocTypeExpression(mayOmitBraces) {
|
|
const pos = getNodePos();
|
|
const hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18 /* OpenBraceToken */);
|
|
const type = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
|
|
if (!mayOmitBraces || hasBrace) {
|
|
parseExpectedJSDoc(19 /* CloseBraceToken */);
|
|
}
|
|
const result = factory2.createJSDocTypeExpression(type);
|
|
fixupParentReferences(result);
|
|
return finishNode(result, pos);
|
|
}
|
|
JSDocParser2.parseJSDocTypeExpression = parseJSDocTypeExpression;
|
|
function parseJSDocNameReference() {
|
|
const pos = getNodePos();
|
|
const hasBrace = parseOptional(18 /* OpenBraceToken */);
|
|
const p2 = getNodePos();
|
|
let entityName = parseEntityName(false);
|
|
while (token() === 80 /* PrivateIdentifier */) {
|
|
reScanHashToken();
|
|
nextTokenJSDoc();
|
|
entityName = finishNode(factory2.createJSDocMemberName(entityName, parseIdentifier()), p2);
|
|
}
|
|
if (hasBrace) {
|
|
parseExpectedJSDoc(19 /* CloseBraceToken */);
|
|
}
|
|
const result = factory2.createJSDocNameReference(entityName);
|
|
fixupParentReferences(result);
|
|
return finishNode(result, pos);
|
|
}
|
|
JSDocParser2.parseJSDocNameReference = parseJSDocNameReference;
|
|
function parseIsolatedJSDocComment(content, start, length2) {
|
|
initializeState("", content, 99 /* Latest */, void 0, 1 /* JS */);
|
|
const jsDoc = doInsideOfContext(8388608 /* JSDoc */, () => parseJSDocCommentWorker(start, length2));
|
|
const sourceFile = { languageVariant: 0 /* Standard */, text: content };
|
|
const diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
clearState();
|
|
return jsDoc ? { jsDoc, diagnostics } : void 0;
|
|
}
|
|
JSDocParser2.parseIsolatedJSDocComment = parseIsolatedJSDocComment;
|
|
function parseJSDocComment(parent, start, length2) {
|
|
const saveToken = currentToken;
|
|
const saveParseDiagnosticsLength = parseDiagnostics.length;
|
|
const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
|
|
const comment = doInsideOfContext(8388608 /* JSDoc */, () => parseJSDocCommentWorker(start, length2));
|
|
setParent(comment, parent);
|
|
if (contextFlags & 262144 /* JavaScriptFile */) {
|
|
if (!jsDocDiagnostics) {
|
|
jsDocDiagnostics = [];
|
|
}
|
|
jsDocDiagnostics.push(...parseDiagnostics);
|
|
}
|
|
currentToken = saveToken;
|
|
parseDiagnostics.length = saveParseDiagnosticsLength;
|
|
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
|
|
return comment;
|
|
}
|
|
JSDocParser2.parseJSDocComment = parseJSDocComment;
|
|
let JSDocState;
|
|
((JSDocState2) => {
|
|
JSDocState2[JSDocState2["BeginningOfLine"] = 0] = "BeginningOfLine";
|
|
JSDocState2[JSDocState2["SawAsterisk"] = 1] = "SawAsterisk";
|
|
JSDocState2[JSDocState2["SavingComments"] = 2] = "SavingComments";
|
|
JSDocState2[JSDocState2["SavingBackticks"] = 3] = "SavingBackticks";
|
|
})(JSDocState || (JSDocState = {}));
|
|
let PropertyLikeParse;
|
|
((PropertyLikeParse2) => {
|
|
PropertyLikeParse2[PropertyLikeParse2["Property"] = 1] = "Property";
|
|
PropertyLikeParse2[PropertyLikeParse2["Parameter"] = 2] = "Parameter";
|
|
PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
|
|
})(PropertyLikeParse || (PropertyLikeParse = {}));
|
|
function parseJSDocCommentWorker(start = 0, length2) {
|
|
const content = sourceText;
|
|
const end = length2 === void 0 ? content.length : start + length2;
|
|
length2 = end - start;
|
|
Debug.assert(start >= 0);
|
|
Debug.assert(start <= end);
|
|
Debug.assert(end <= content.length);
|
|
if (!isJSDocLikeText(content, start)) {
|
|
return void 0;
|
|
}
|
|
let tags;
|
|
let tagsPos;
|
|
let tagsEnd;
|
|
let linkEnd;
|
|
let commentsPos;
|
|
let comments = [];
|
|
const parts = [];
|
|
return scanner.scanRange(start + 3, length2 - 5, () => {
|
|
let state = 1 /* SawAsterisk */;
|
|
let margin;
|
|
let indent2 = start - (content.lastIndexOf("\n", start) + 1) + 4;
|
|
function pushComment(text) {
|
|
if (!margin) {
|
|
margin = indent2;
|
|
}
|
|
comments.push(text);
|
|
indent2 += text.length;
|
|
}
|
|
nextTokenJSDoc();
|
|
while (parseOptionalJsdoc(5 /* WhitespaceTrivia */))
|
|
;
|
|
if (parseOptionalJsdoc(4 /* NewLineTrivia */)) {
|
|
state = 0 /* BeginningOfLine */;
|
|
indent2 = 0;
|
|
}
|
|
loop:
|
|
while (true) {
|
|
switch (token()) {
|
|
case 59 /* AtToken */:
|
|
if (state === 0 /* BeginningOfLine */ || state === 1 /* SawAsterisk */) {
|
|
removeTrailingWhitespace(comments);
|
|
if (!commentsPos)
|
|
commentsPos = getNodePos();
|
|
addTag(parseTag(indent2));
|
|
state = 0 /* BeginningOfLine */;
|
|
margin = void 0;
|
|
} else {
|
|
pushComment(scanner.getTokenText());
|
|
}
|
|
break;
|
|
case 4 /* NewLineTrivia */:
|
|
comments.push(scanner.getTokenText());
|
|
state = 0 /* BeginningOfLine */;
|
|
indent2 = 0;
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
const asterisk = scanner.getTokenText();
|
|
if (state === 1 /* SawAsterisk */ || state === 2 /* SavingComments */) {
|
|
state = 2 /* SavingComments */;
|
|
pushComment(asterisk);
|
|
} else {
|
|
state = 1 /* SawAsterisk */;
|
|
indent2 += asterisk.length;
|
|
}
|
|
break;
|
|
case 5 /* WhitespaceTrivia */:
|
|
const whitespace = scanner.getTokenText();
|
|
if (state === 2 /* SavingComments */) {
|
|
comments.push(whitespace);
|
|
} else if (margin !== void 0 && indent2 + whitespace.length > margin) {
|
|
comments.push(whitespace.slice(margin - indent2));
|
|
}
|
|
indent2 += whitespace.length;
|
|
break;
|
|
case 1 /* EndOfFileToken */:
|
|
break loop;
|
|
case 18 /* OpenBraceToken */:
|
|
state = 2 /* SavingComments */;
|
|
const commentEnd = scanner.getStartPos();
|
|
const linkStart = scanner.getTextPos() - 1;
|
|
const link = parseJSDocLink(linkStart);
|
|
if (link) {
|
|
if (!linkEnd) {
|
|
removeLeadingNewlines(comments);
|
|
}
|
|
parts.push(finishNode(factory2.createJSDocText(comments.join("")), linkEnd != null ? linkEnd : start, commentEnd));
|
|
parts.push(link);
|
|
comments = [];
|
|
linkEnd = scanner.getTextPos();
|
|
break;
|
|
}
|
|
default:
|
|
state = 2 /* SavingComments */;
|
|
pushComment(scanner.getTokenText());
|
|
break;
|
|
}
|
|
nextTokenJSDoc();
|
|
}
|
|
removeTrailingWhitespace(comments);
|
|
if (parts.length && comments.length) {
|
|
parts.push(finishNode(factory2.createJSDocText(comments.join("")), linkEnd != null ? linkEnd : start, commentsPos));
|
|
}
|
|
if (parts.length && tags)
|
|
Debug.assertIsDefined(commentsPos, "having parsed tags implies that the end of the comment span should be set");
|
|
const tagsArray = tags && createNodeArray(tags, tagsPos, tagsEnd);
|
|
return finishNode(factory2.createJSDocComment(parts.length ? createNodeArray(parts, start, commentsPos) : comments.length ? comments.join("") : void 0, tagsArray), start, end);
|
|
});
|
|
function removeLeadingNewlines(comments2) {
|
|
while (comments2.length && (comments2[0] === "\n" || comments2[0] === "\r")) {
|
|
comments2.shift();
|
|
}
|
|
}
|
|
function removeTrailingWhitespace(comments2) {
|
|
while (comments2.length && comments2[comments2.length - 1].trim() === "") {
|
|
comments2.pop();
|
|
}
|
|
}
|
|
function isNextNonwhitespaceTokenEndOfFile() {
|
|
while (true) {
|
|
nextTokenJSDoc();
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
return true;
|
|
}
|
|
if (!(token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function skipWhitespace() {
|
|
if (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
|
|
return;
|
|
}
|
|
}
|
|
while (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
nextTokenJSDoc();
|
|
}
|
|
}
|
|
function skipWhitespaceOrAsterisk() {
|
|
if (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
|
|
return "";
|
|
}
|
|
}
|
|
let precedingLineBreak = scanner.hasPrecedingLineBreak();
|
|
let seenLineBreak = false;
|
|
let indentText = "";
|
|
while (precedingLineBreak && token() === 41 /* AsteriskToken */ || token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
indentText += scanner.getTokenText();
|
|
if (token() === 4 /* NewLineTrivia */) {
|
|
precedingLineBreak = true;
|
|
seenLineBreak = true;
|
|
indentText = "";
|
|
} else if (token() === 41 /* AsteriskToken */) {
|
|
precedingLineBreak = false;
|
|
}
|
|
nextTokenJSDoc();
|
|
}
|
|
return seenLineBreak ? indentText : "";
|
|
}
|
|
function parseTag(margin) {
|
|
Debug.assert(token() === 59 /* AtToken */);
|
|
const start2 = scanner.getTokenPos();
|
|
nextTokenJSDoc();
|
|
const tagName = parseJSDocIdentifierName(void 0);
|
|
const indentText = skipWhitespaceOrAsterisk();
|
|
let tag;
|
|
switch (tagName.escapedText) {
|
|
case "author":
|
|
tag = parseAuthorTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "implements":
|
|
tag = parseImplementsTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "augments":
|
|
case "extends":
|
|
tag = parseAugmentsTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "class":
|
|
case "constructor":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocClassTag, tagName, margin, indentText);
|
|
break;
|
|
case "public":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocPublicTag, tagName, margin, indentText);
|
|
break;
|
|
case "private":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocPrivateTag, tagName, margin, indentText);
|
|
break;
|
|
case "protected":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocProtectedTag, tagName, margin, indentText);
|
|
break;
|
|
case "readonly":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocReadonlyTag, tagName, margin, indentText);
|
|
break;
|
|
case "override":
|
|
tag = parseSimpleTag(start2, factory2.createJSDocOverrideTag, tagName, margin, indentText);
|
|
break;
|
|
case "deprecated":
|
|
hasDeprecatedTag = true;
|
|
tag = parseSimpleTag(start2, factory2.createJSDocDeprecatedTag, tagName, margin, indentText);
|
|
break;
|
|
case "this":
|
|
tag = parseThisTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "enum":
|
|
tag = parseEnumTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "arg":
|
|
case "argument":
|
|
case "param":
|
|
return parseParameterOrPropertyTag(start2, tagName, 2 /* Parameter */, margin);
|
|
case "return":
|
|
case "returns":
|
|
tag = parseReturnTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "template":
|
|
tag = parseTemplateTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "type":
|
|
tag = parseTypeTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "typedef":
|
|
tag = parseTypedefTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "callback":
|
|
tag = parseCallbackTag(start2, tagName, margin, indentText);
|
|
break;
|
|
case "see":
|
|
tag = parseSeeTag(start2, tagName, margin, indentText);
|
|
break;
|
|
default:
|
|
tag = parseUnknownTag(start2, tagName, margin, indentText);
|
|
break;
|
|
}
|
|
return tag;
|
|
}
|
|
function parseTrailingTagComments(pos, end2, margin, indentText) {
|
|
if (!indentText) {
|
|
margin += end2 - pos;
|
|
}
|
|
return parseTagComments(margin, indentText.slice(margin));
|
|
}
|
|
function parseTagComments(indent2, initialMargin) {
|
|
const commentsPos2 = getNodePos();
|
|
let comments2 = [];
|
|
const parts2 = [];
|
|
let linkEnd2;
|
|
let state = 0 /* BeginningOfLine */;
|
|
let previousWhitespace = true;
|
|
let margin;
|
|
function pushComment(text) {
|
|
if (!margin) {
|
|
margin = indent2;
|
|
}
|
|
comments2.push(text);
|
|
indent2 += text.length;
|
|
}
|
|
if (initialMargin !== void 0) {
|
|
if (initialMargin !== "") {
|
|
pushComment(initialMargin);
|
|
}
|
|
state = 1 /* SawAsterisk */;
|
|
}
|
|
let tok = token();
|
|
loop:
|
|
while (true) {
|
|
switch (tok) {
|
|
case 4 /* NewLineTrivia */:
|
|
state = 0 /* BeginningOfLine */;
|
|
comments2.push(scanner.getTokenText());
|
|
indent2 = 0;
|
|
break;
|
|
case 59 /* AtToken */:
|
|
if (state === 3 /* SavingBackticks */ || state === 2 /* SavingComments */ && (!previousWhitespace || lookAhead(isNextJSDocTokenWhitespace))) {
|
|
comments2.push(scanner.getTokenText());
|
|
break;
|
|
}
|
|
scanner.setTextPos(scanner.getTextPos() - 1);
|
|
case 1 /* EndOfFileToken */:
|
|
break loop;
|
|
case 5 /* WhitespaceTrivia */:
|
|
if (state === 2 /* SavingComments */ || state === 3 /* SavingBackticks */) {
|
|
pushComment(scanner.getTokenText());
|
|
} else {
|
|
const whitespace = scanner.getTokenText();
|
|
if (margin !== void 0 && indent2 + whitespace.length > margin) {
|
|
comments2.push(whitespace.slice(margin - indent2));
|
|
}
|
|
indent2 += whitespace.length;
|
|
}
|
|
break;
|
|
case 18 /* OpenBraceToken */:
|
|
state = 2 /* SavingComments */;
|
|
const commentEnd = scanner.getStartPos();
|
|
const linkStart = scanner.getTextPos() - 1;
|
|
const link = parseJSDocLink(linkStart);
|
|
if (link) {
|
|
parts2.push(finishNode(factory2.createJSDocText(comments2.join("")), linkEnd2 != null ? linkEnd2 : commentsPos2, commentEnd));
|
|
parts2.push(link);
|
|
comments2 = [];
|
|
linkEnd2 = scanner.getTextPos();
|
|
} else {
|
|
pushComment(scanner.getTokenText());
|
|
}
|
|
break;
|
|
case 61 /* BacktickToken */:
|
|
if (state === 3 /* SavingBackticks */) {
|
|
state = 2 /* SavingComments */;
|
|
} else {
|
|
state = 3 /* SavingBackticks */;
|
|
}
|
|
pushComment(scanner.getTokenText());
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
if (state === 0 /* BeginningOfLine */) {
|
|
state = 1 /* SawAsterisk */;
|
|
indent2 += 1;
|
|
break;
|
|
}
|
|
default:
|
|
if (state !== 3 /* SavingBackticks */) {
|
|
state = 2 /* SavingComments */;
|
|
}
|
|
pushComment(scanner.getTokenText());
|
|
break;
|
|
}
|
|
previousWhitespace = token() === 5 /* WhitespaceTrivia */;
|
|
tok = nextTokenJSDoc();
|
|
}
|
|
removeLeadingNewlines(comments2);
|
|
removeTrailingWhitespace(comments2);
|
|
if (parts2.length) {
|
|
if (comments2.length) {
|
|
parts2.push(finishNode(factory2.createJSDocText(comments2.join("")), linkEnd2 != null ? linkEnd2 : commentsPos2));
|
|
}
|
|
return createNodeArray(parts2, commentsPos2, scanner.getTextPos());
|
|
} else if (comments2.length) {
|
|
return comments2.join("");
|
|
}
|
|
}
|
|
function isNextJSDocTokenWhitespace() {
|
|
const next = nextTokenJSDoc();
|
|
return next === 5 /* WhitespaceTrivia */ || next === 4 /* NewLineTrivia */;
|
|
}
|
|
function parseJSDocLink(start2) {
|
|
const linkType = tryParse(parseJSDocLinkPrefix);
|
|
if (!linkType) {
|
|
return void 0;
|
|
}
|
|
nextTokenJSDoc();
|
|
skipWhitespace();
|
|
const p2 = getNodePos();
|
|
let name = tokenIsIdentifierOrKeyword(token()) ? parseEntityName(true) : void 0;
|
|
if (name) {
|
|
while (token() === 80 /* PrivateIdentifier */) {
|
|
reScanHashToken();
|
|
nextTokenJSDoc();
|
|
name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), p2);
|
|
}
|
|
}
|
|
const text = [];
|
|
while (token() !== 19 /* CloseBraceToken */ && token() !== 4 /* NewLineTrivia */ && token() !== 1 /* EndOfFileToken */) {
|
|
text.push(scanner.getTokenText());
|
|
nextTokenJSDoc();
|
|
}
|
|
const create = linkType === "link" ? factory2.createJSDocLink : linkType === "linkcode" ? factory2.createJSDocLinkCode : factory2.createJSDocLinkPlain;
|
|
return finishNode(create(name, text.join("")), start2, scanner.getTextPos());
|
|
}
|
|
function parseJSDocLinkPrefix() {
|
|
skipWhitespaceOrAsterisk();
|
|
if (token() === 18 /* OpenBraceToken */ && nextTokenJSDoc() === 59 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
|
|
const kind = scanner.getTokenValue();
|
|
if (isJSDocLinkTag(kind))
|
|
return kind;
|
|
}
|
|
}
|
|
function isJSDocLinkTag(kind) {
|
|
return kind === "link" || kind === "linkcode" || kind === "linkplain";
|
|
}
|
|
function parseUnknownTag(start2, tagName, indent2, indentText) {
|
|
return finishNode(factory2.createJSDocUnknownTag(tagName, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
|
|
}
|
|
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 /* OpenBraceToken */ ? parseJSDocTypeExpression() : void 0;
|
|
}
|
|
function parseBracketNameInPropertyAndParamTag() {
|
|
const isBracketed = parseOptionalJsdoc(22 /* OpenBracketToken */);
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
}
|
|
const isBackquoted = parseOptionalJsdoc(61 /* BacktickToken */);
|
|
const name = parseJSDocEntityName();
|
|
if (isBackquoted) {
|
|
parseExpectedTokenJSDoc(61 /* BacktickToken */);
|
|
}
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
if (parseOptionalToken(63 /* EqualsToken */)) {
|
|
parseExpression();
|
|
}
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
return { name, isBracketed };
|
|
}
|
|
function isObjectOrObjectArrayTypeReference(node) {
|
|
switch (node.kind) {
|
|
case 149 /* ObjectKeyword */:
|
|
return true;
|
|
case 185 /* ArrayType */:
|
|
return isObjectOrObjectArrayTypeReference(node.elementType);
|
|
default:
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments;
|
|
}
|
|
}
|
|
function parseParameterOrPropertyTag(start2, tagName, target, indent2) {
|
|
let typeExpression = tryParseTypeExpression();
|
|
let isNameFirst = !typeExpression;
|
|
skipWhitespaceOrAsterisk();
|
|
const { name, isBracketed } = parseBracketNameInPropertyAndParamTag();
|
|
const indentText = skipWhitespaceOrAsterisk();
|
|
if (isNameFirst && !lookAhead(parseJSDocLinkPrefix)) {
|
|
typeExpression = tryParseTypeExpression();
|
|
}
|
|
const comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
|
|
const nestedTypeLiteral = target !== 4 /* CallbackParameter */ && parseNestedTypeLiteral(typeExpression, name, target, indent2);
|
|
if (nestedTypeLiteral) {
|
|
typeExpression = nestedTypeLiteral;
|
|
isNameFirst = true;
|
|
}
|
|
const result = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
|
|
return finishNode(result, start2);
|
|
}
|
|
function parseNestedTypeLiteral(typeExpression, name, target, indent2) {
|
|
if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
|
|
const pos = getNodePos();
|
|
let child;
|
|
let children;
|
|
while (child = tryParse(() => parseChildParameterOrPropertyTag(target, indent2, name))) {
|
|
if (child.kind === 343 /* JSDocParameterTag */ || child.kind === 350 /* JSDocPropertyTag */) {
|
|
children = append(children, child);
|
|
}
|
|
}
|
|
if (children) {
|
|
const literal = finishNode(factory2.createJSDocTypeLiteral(children, typeExpression.type.kind === 185 /* ArrayType */), pos);
|
|
return finishNode(factory2.createJSDocTypeExpression(literal), pos);
|
|
}
|
|
}
|
|
}
|
|
function parseReturnTag(start2, tagName, indent2, indentText) {
|
|
if (some(tags, isJSDocReturnTag)) {
|
|
parseErrorAt(tagName.pos, scanner.getTokenPos(), Diagnostics._0_tag_already_specified, tagName.escapedText);
|
|
}
|
|
const typeExpression = tryParseTypeExpression();
|
|
return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
|
|
}
|
|
function parseTypeTag(start2, tagName, indent2, indentText) {
|
|
if (some(tags, isJSDocTypeTag)) {
|
|
parseErrorAt(tagName.pos, scanner.getTokenPos(), Diagnostics._0_tag_already_specified, tagName.escapedText);
|
|
}
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
const comments2 = indent2 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent2, indentText) : void 0;
|
|
return finishNode(factory2.createJSDocTypeTag(tagName, typeExpression, comments2), start2);
|
|
}
|
|
function parseSeeTag(start2, tagName, indent2, indentText) {
|
|
const isMarkdownOrJSDocLink = token() === 22 /* OpenBracketToken */ || lookAhead(() => nextTokenJSDoc() === 59 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && isJSDocLinkTag(scanner.getTokenValue()));
|
|
const nameExpression = isMarkdownOrJSDocLink ? void 0 : parseJSDocNameReference();
|
|
const comments2 = indent2 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), indent2, indentText) : void 0;
|
|
return finishNode(factory2.createJSDocSeeTag(tagName, nameExpression, comments2), start2);
|
|
}
|
|
function parseAuthorTag(start2, tagName, indent2, indentText) {
|
|
const commentStart = getNodePos();
|
|
const textOnly = parseAuthorNameAndEmail();
|
|
let commentEnd = scanner.getStartPos();
|
|
const comments2 = parseTrailingTagComments(start2, commentEnd, indent2, indentText);
|
|
if (!comments2) {
|
|
commentEnd = scanner.getStartPos();
|
|
}
|
|
const allParts = typeof comments2 !== "string" ? createNodeArray(concatenate([finishNode(textOnly, commentStart, commentEnd)], comments2), commentStart) : textOnly.text + comments2;
|
|
return finishNode(factory2.createJSDocAuthorTag(tagName, allParts), start2);
|
|
}
|
|
function parseAuthorNameAndEmail() {
|
|
const comments2 = [];
|
|
let inEmail = false;
|
|
let token2 = scanner.getToken();
|
|
while (token2 !== 1 /* EndOfFileToken */ && token2 !== 4 /* NewLineTrivia */) {
|
|
if (token2 === 29 /* LessThanToken */) {
|
|
inEmail = true;
|
|
} else if (token2 === 59 /* AtToken */ && !inEmail) {
|
|
break;
|
|
} else if (token2 === 31 /* GreaterThanToken */ && inEmail) {
|
|
comments2.push(scanner.getTokenText());
|
|
scanner.setTextPos(scanner.getTokenPos() + 1);
|
|
break;
|
|
}
|
|
comments2.push(scanner.getTokenText());
|
|
token2 = nextTokenJSDoc();
|
|
}
|
|
return factory2.createJSDocText(comments2.join(""));
|
|
}
|
|
function parseImplementsTag(start2, tagName, margin, indentText) {
|
|
const className = parseExpressionWithTypeArgumentsForAugments();
|
|
return finishNode(factory2.createJSDocImplementsTag(tagName, className, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
|
|
}
|
|
function parseAugmentsTag(start2, tagName, margin, indentText) {
|
|
const className = parseExpressionWithTypeArgumentsForAugments();
|
|
return finishNode(factory2.createJSDocAugmentsTag(tagName, className, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
|
|
}
|
|
function parseExpressionWithTypeArgumentsForAugments() {
|
|
const usedBrace = parseOptional(18 /* OpenBraceToken */);
|
|
const pos = getNodePos();
|
|
const expression = parsePropertyAccessEntityNameExpression();
|
|
const typeArguments = tryParseTypeArguments();
|
|
const node = factory2.createExpressionWithTypeArguments(expression, typeArguments);
|
|
const res = finishNode(node, pos);
|
|
if (usedBrace) {
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
}
|
|
return res;
|
|
}
|
|
function parsePropertyAccessEntityNameExpression() {
|
|
const pos = getNodePos();
|
|
let node = parseJSDocIdentifierName();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
const name = parseJSDocIdentifierName();
|
|
node = finishNode(factory2.createPropertyAccessExpression(node, name), pos);
|
|
}
|
|
return node;
|
|
}
|
|
function parseSimpleTag(start2, createTag, tagName, margin, indentText) {
|
|
return finishNode(createTag(tagName, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
|
|
}
|
|
function parseThisTag(start2, tagName, margin, indentText) {
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
skipWhitespace();
|
|
return finishNode(factory2.createJSDocThisTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
|
|
}
|
|
function parseEnumTag(start2, tagName, margin, indentText) {
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
skipWhitespace();
|
|
return finishNode(factory2.createJSDocEnumTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), margin, indentText)), start2);
|
|
}
|
|
function parseTypedefTag(start2, tagName, indent2, indentText) {
|
|
var _a2;
|
|
let typeExpression = tryParseTypeExpression();
|
|
skipWhitespaceOrAsterisk();
|
|
const fullName = parseJSDocTypeNameWithNamespace();
|
|
skipWhitespace();
|
|
let comment = parseTagComments(indent2);
|
|
let end2;
|
|
if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
|
|
let child;
|
|
let childTypeTag;
|
|
let jsDocPropertyTags;
|
|
let hasChildren = false;
|
|
while (child = tryParse(() => parseChildPropertyTag(indent2))) {
|
|
hasChildren = true;
|
|
if (child.kind === 346 /* JSDocTypeTag */) {
|
|
if (childTypeTag) {
|
|
const lastError = parseErrorAtCurrentToken(Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
|
|
if (lastError) {
|
|
addRelatedInfo(lastError, createDetachedDiagnostic(fileName, 0, 0, Diagnostics.The_tag_was_first_specified_here));
|
|
}
|
|
break;
|
|
} else {
|
|
childTypeTag = child;
|
|
}
|
|
} else {
|
|
jsDocPropertyTags = append(jsDocPropertyTags, child);
|
|
}
|
|
}
|
|
if (hasChildren) {
|
|
const isArrayType = typeExpression && typeExpression.type.kind === 185 /* ArrayType */;
|
|
const jsdocTypeLiteral = factory2.createJSDocTypeLiteral(jsDocPropertyTags, isArrayType);
|
|
typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ? childTypeTag.typeExpression : finishNode(jsdocTypeLiteral, start2);
|
|
end2 = typeExpression.end;
|
|
}
|
|
}
|
|
end2 = end2 || comment !== void 0 ? getNodePos() : ((_a2 = fullName != null ? fullName : typeExpression) != null ? _a2 : tagName).end;
|
|
if (!comment) {
|
|
comment = parseTrailingTagComments(start2, end2, indent2, indentText);
|
|
}
|
|
const typedefTag = factory2.createJSDocTypedefTag(tagName, typeExpression, fullName, comment);
|
|
return finishNode(typedefTag, start2, end2);
|
|
}
|
|
function parseJSDocTypeNameWithNamespace(nested) {
|
|
const pos = scanner.getTokenPos();
|
|
if (!tokenIsIdentifierOrKeyword(token())) {
|
|
return void 0;
|
|
}
|
|
const typeNameOrNamespaceName = parseJSDocIdentifierName();
|
|
if (parseOptional(24 /* DotToken */)) {
|
|
const body = parseJSDocTypeNameWithNamespace(true);
|
|
const jsDocNamespaceNode = factory2.createModuleDeclaration(
|
|
void 0,
|
|
typeNameOrNamespaceName,
|
|
body,
|
|
nested ? 4 /* NestedNamespace */ : void 0
|
|
);
|
|
return finishNode(jsDocNamespaceNode, pos);
|
|
}
|
|
if (nested) {
|
|
typeNameOrNamespaceName.isInJSDocNamespace = true;
|
|
}
|
|
return typeNameOrNamespaceName;
|
|
}
|
|
function parseCallbackTagParameters(indent2) {
|
|
const pos = getNodePos();
|
|
let child;
|
|
let parameters;
|
|
while (child = tryParse(() => parseChildParameterOrPropertyTag(4 /* CallbackParameter */, indent2))) {
|
|
parameters = append(parameters, child);
|
|
}
|
|
return createNodeArray(parameters || [], pos);
|
|
}
|
|
function parseCallbackTag(start2, tagName, indent2, indentText) {
|
|
const fullName = parseJSDocTypeNameWithNamespace();
|
|
skipWhitespace();
|
|
let comment = parseTagComments(indent2);
|
|
const parameters = parseCallbackTagParameters(indent2);
|
|
const returnTag = tryParse(() => {
|
|
if (parseOptionalJsdoc(59 /* AtToken */)) {
|
|
const tag = parseTag(indent2);
|
|
if (tag && tag.kind === 344 /* JSDocReturnTag */) {
|
|
return tag;
|
|
}
|
|
}
|
|
});
|
|
const typeExpression = finishNode(factory2.createJSDocSignature(void 0, parameters, returnTag), start2);
|
|
if (!comment) {
|
|
comment = parseTrailingTagComments(start2, getNodePos(), indent2, indentText);
|
|
}
|
|
const end2 = comment !== void 0 ? getNodePos() : typeExpression.end;
|
|
return finishNode(factory2.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start2, end2);
|
|
}
|
|
function escapedTextsEqual(a, b) {
|
|
while (!isIdentifier(a) || !isIdentifier(b)) {
|
|
if (!isIdentifier(a) && !isIdentifier(b) && a.right.escapedText === b.right.escapedText) {
|
|
a = a.left;
|
|
b = b.left;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return a.escapedText === b.escapedText;
|
|
}
|
|
function parseChildPropertyTag(indent2) {
|
|
return parseChildParameterOrPropertyTag(1 /* Property */, indent2);
|
|
}
|
|
function parseChildParameterOrPropertyTag(target, indent2, name) {
|
|
let canParseTag = true;
|
|
let seenAsterisk = false;
|
|
while (true) {
|
|
switch (nextTokenJSDoc()) {
|
|
case 59 /* AtToken */:
|
|
if (canParseTag) {
|
|
const child = tryParseChildTag(target, indent2);
|
|
if (child && (child.kind === 343 /* JSDocParameterTag */ || child.kind === 350 /* JSDocPropertyTag */) && target !== 4 /* CallbackParameter */ && name && (isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) {
|
|
return false;
|
|
}
|
|
return child;
|
|
}
|
|
seenAsterisk = false;
|
|
break;
|
|
case 4 /* NewLineTrivia */:
|
|
canParseTag = true;
|
|
seenAsterisk = false;
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
if (seenAsterisk) {
|
|
canParseTag = false;
|
|
}
|
|
seenAsterisk = true;
|
|
break;
|
|
case 79 /* Identifier */:
|
|
canParseTag = false;
|
|
break;
|
|
case 1 /* EndOfFileToken */:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function tryParseChildTag(target, indent2) {
|
|
Debug.assert(token() === 59 /* AtToken */);
|
|
const start2 = scanner.getStartPos();
|
|
nextTokenJSDoc();
|
|
const tagName = parseJSDocIdentifierName();
|
|
skipWhitespace();
|
|
let t;
|
|
switch (tagName.escapedText) {
|
|
case "type":
|
|
return target === 1 /* Property */ && parseTypeTag(start2, tagName);
|
|
case "prop":
|
|
case "property":
|
|
t = 1 /* Property */;
|
|
break;
|
|
case "arg":
|
|
case "argument":
|
|
case "param":
|
|
t = 2 /* Parameter */ | 4 /* CallbackParameter */;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (!(target & t)) {
|
|
return false;
|
|
}
|
|
return parseParameterOrPropertyTag(start2, tagName, target, indent2);
|
|
}
|
|
function parseTemplateTagTypeParameter() {
|
|
const typeParameterPos = getNodePos();
|
|
const isBracketed = parseOptionalJsdoc(22 /* OpenBracketToken */);
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
}
|
|
const name = parseJSDocIdentifierName(Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces);
|
|
let defaultType;
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
parseExpected(63 /* EqualsToken */);
|
|
defaultType = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
return finishNode(factory2.createTypeParameterDeclaration(void 0, name, void 0, defaultType), typeParameterPos);
|
|
}
|
|
function parseTemplateTagTypeParameters() {
|
|
const pos = getNodePos();
|
|
const typeParameters = [];
|
|
do {
|
|
skipWhitespace();
|
|
const node = parseTemplateTagTypeParameter();
|
|
if (node !== void 0) {
|
|
typeParameters.push(node);
|
|
}
|
|
skipWhitespaceOrAsterisk();
|
|
} while (parseOptionalJsdoc(27 /* CommaToken */));
|
|
return createNodeArray(typeParameters, pos);
|
|
}
|
|
function parseTemplateTag(start2, tagName, indent2, indentText) {
|
|
const constraint = token() === 18 /* OpenBraceToken */ ? parseJSDocTypeExpression() : void 0;
|
|
const typeParameters = parseTemplateTagTypeParameters();
|
|
return finishNode(factory2.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
|
|
}
|
|
function parseOptionalJsdoc(t) {
|
|
if (token() === t) {
|
|
nextTokenJSDoc();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseJSDocEntityName() {
|
|
let entity = parseJSDocIdentifierName();
|
|
if (parseOptional(22 /* OpenBracketToken */)) {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
const name = parseJSDocIdentifierName();
|
|
if (parseOptional(22 /* OpenBracketToken */)) {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
entity = createQualifiedName(entity, name);
|
|
}
|
|
return entity;
|
|
}
|
|
function parseJSDocIdentifierName(message) {
|
|
if (!tokenIsIdentifierOrKeyword(token())) {
|
|
return createMissingNode(79 /* Identifier */, !message, message || Diagnostics.Identifier_expected);
|
|
}
|
|
identifierCount++;
|
|
const pos = scanner.getTokenPos();
|
|
const end2 = scanner.getTextPos();
|
|
const originalKeywordKind = token();
|
|
const text = internIdentifier(scanner.getTokenValue());
|
|
const result = finishNode(factory2.createIdentifier(text, void 0, originalKeywordKind), pos, end2);
|
|
nextTokenJSDoc();
|
|
return result;
|
|
}
|
|
}
|
|
})(JSDocParser = Parser2.JSDocParser || (Parser2.JSDocParser = {}));
|
|
})(Parser || (Parser = {}));
|
|
var IncrementalParser;
|
|
((IncrementalParser2) => {
|
|
function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) {
|
|
aggressiveChecks = aggressiveChecks || Debug.shouldAssert(2 /* Aggressive */);
|
|
checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks);
|
|
if (textChangeRangeIsUnchanged(textChangeRange)) {
|
|
return sourceFile;
|
|
}
|
|
if (sourceFile.statements.length === 0) {
|
|
return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, void 0, true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
|
|
}
|
|
const incrementalSourceFile = sourceFile;
|
|
Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
|
|
incrementalSourceFile.hasBeenIncrementallyParsed = true;
|
|
Parser.fixupParentReferences(incrementalSourceFile);
|
|
const oldText = sourceFile.text;
|
|
const syntaxCursor = createSyntaxCursor(sourceFile);
|
|
const changeRange = extendToAffectedRange(sourceFile, textChangeRange);
|
|
checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
|
|
Debug.assert(changeRange.span.start <= textChangeRange.span.start);
|
|
Debug.assert(textSpanEnd(changeRange.span) === textSpanEnd(textChangeRange.span));
|
|
Debug.assert(textSpanEnd(textChangeRangeNewSpan(changeRange)) === textSpanEnd(textChangeRangeNewSpan(textChangeRange)));
|
|
const delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
|
|
updateTokenPositionsAndMarkElements(
|
|
incrementalSourceFile,
|
|
changeRange.span.start,
|
|
textSpanEnd(changeRange.span),
|
|
textSpanEnd(textChangeRangeNewSpan(changeRange)),
|
|
delta,
|
|
oldText,
|
|
newText,
|
|
aggressiveChecks
|
|
);
|
|
const result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
|
|
result.commentDirectives = getNewCommentDirectives(
|
|
sourceFile.commentDirectives,
|
|
result.commentDirectives,
|
|
changeRange.span.start,
|
|
textSpanEnd(changeRange.span),
|
|
delta,
|
|
oldText,
|
|
newText,
|
|
aggressiveChecks
|
|
);
|
|
result.impliedNodeFormat = sourceFile.impliedNodeFormat;
|
|
return result;
|
|
}
|
|
IncrementalParser2.updateSourceFile = updateSourceFile;
|
|
function getNewCommentDirectives(oldDirectives, newDirectives, changeStart, changeRangeOldEnd, delta, oldText, newText, aggressiveChecks) {
|
|
if (!oldDirectives)
|
|
return newDirectives;
|
|
let commentDirectives;
|
|
let addedNewlyScannedDirectives = false;
|
|
for (const directive of oldDirectives) {
|
|
const { range, type } = directive;
|
|
if (range.end < changeStart) {
|
|
commentDirectives = append(commentDirectives, directive);
|
|
} else if (range.pos > changeRangeOldEnd) {
|
|
addNewlyScannedDirectives();
|
|
const updatedDirective = {
|
|
range: { pos: range.pos + delta, end: range.end + delta },
|
|
type
|
|
};
|
|
commentDirectives = append(commentDirectives, updatedDirective);
|
|
if (aggressiveChecks) {
|
|
Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
|
|
}
|
|
}
|
|
}
|
|
addNewlyScannedDirectives();
|
|
return commentDirectives;
|
|
function addNewlyScannedDirectives() {
|
|
if (addedNewlyScannedDirectives)
|
|
return;
|
|
addedNewlyScannedDirectives = true;
|
|
if (!commentDirectives) {
|
|
commentDirectives = newDirectives;
|
|
} else if (newDirectives) {
|
|
commentDirectives.push(...newDirectives);
|
|
}
|
|
}
|
|
}
|
|
function moveElementEntirelyPastChangeRange(element, isArray2, delta, oldText, newText, aggressiveChecks) {
|
|
if (isArray2) {
|
|
visitArray2(element);
|
|
} else {
|
|
visitNode3(element);
|
|
}
|
|
return;
|
|
function visitNode3(node) {
|
|
let text = "";
|
|
if (aggressiveChecks && shouldCheckNode(node)) {
|
|
text = oldText.substring(node.pos, node.end);
|
|
}
|
|
if (node._children) {
|
|
node._children = void 0;
|
|
}
|
|
setTextRangePosEnd(node, node.pos + delta, node.end + delta);
|
|
if (aggressiveChecks && shouldCheckNode(node)) {
|
|
Debug.assert(text === newText.substring(node.pos, node.end));
|
|
}
|
|
forEachChild(node, visitNode3, visitArray2);
|
|
if (hasJSDocNodes(node)) {
|
|
for (const jsDocComment of node.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
checkNodePositions(node, aggressiveChecks);
|
|
}
|
|
function visitArray2(array) {
|
|
array._children = void 0;
|
|
setTextRangePosEnd(array, array.pos + delta, array.end + delta);
|
|
for (const node of array) {
|
|
visitNode3(node);
|
|
}
|
|
}
|
|
}
|
|
function shouldCheckNode(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 79 /* Identifier */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) {
|
|
Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range");
|
|
Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range");
|
|
Debug.assert(element.pos <= element.end);
|
|
const pos = Math.min(element.pos, changeRangeNewEnd);
|
|
const end = element.end >= changeRangeOldEnd ? element.end + delta : Math.min(element.end, changeRangeNewEnd);
|
|
Debug.assert(pos <= end);
|
|
if (element.parent) {
|
|
Debug.assertGreaterThanOrEqual(pos, element.parent.pos);
|
|
Debug.assertLessThanOrEqual(end, element.parent.end);
|
|
}
|
|
setTextRangePosEnd(element, pos, end);
|
|
}
|
|
function checkNodePositions(node, aggressiveChecks) {
|
|
if (aggressiveChecks) {
|
|
let pos = node.pos;
|
|
const visitNode3 = (child) => {
|
|
Debug.assert(child.pos >= pos);
|
|
pos = child.end;
|
|
};
|
|
if (hasJSDocNodes(node)) {
|
|
for (const jsDocComment of node.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
forEachChild(node, visitNode3);
|
|
Debug.assert(pos <= node.end);
|
|
}
|
|
}
|
|
function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) {
|
|
visitNode3(sourceFile);
|
|
return;
|
|
function visitNode3(child) {
|
|
Debug.assert(child.pos <= child.end);
|
|
if (child.pos > changeRangeOldEnd) {
|
|
moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks);
|
|
return;
|
|
}
|
|
const fullEnd = child.end;
|
|
if (fullEnd >= changeStart) {
|
|
child.intersectsChange = true;
|
|
child._children = void 0;
|
|
adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
|
|
forEachChild(child, visitNode3, visitArray2);
|
|
if (hasJSDocNodes(child)) {
|
|
for (const jsDocComment of child.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
checkNodePositions(child, aggressiveChecks);
|
|
return;
|
|
}
|
|
Debug.assert(fullEnd < changeStart);
|
|
}
|
|
function visitArray2(array) {
|
|
Debug.assert(array.pos <= array.end);
|
|
if (array.pos > changeRangeOldEnd) {
|
|
moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks);
|
|
return;
|
|
}
|
|
const fullEnd = array.end;
|
|
if (fullEnd >= changeStart) {
|
|
array.intersectsChange = true;
|
|
array._children = void 0;
|
|
adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
|
|
for (const node of array) {
|
|
visitNode3(node);
|
|
}
|
|
return;
|
|
}
|
|
Debug.assert(fullEnd < changeStart);
|
|
}
|
|
}
|
|
function extendToAffectedRange(sourceFile, changeRange) {
|
|
const maxLookahead = 1;
|
|
let start = changeRange.span.start;
|
|
for (let i = 0; start > 0 && i <= maxLookahead; i++) {
|
|
const nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
|
|
Debug.assert(nearestNode.pos <= start);
|
|
const position = nearestNode.pos;
|
|
start = Math.max(0, position - 1);
|
|
}
|
|
const finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span));
|
|
const finalLength = changeRange.newLength + (changeRange.span.start - start);
|
|
return createTextChangeRange(finalSpan, finalLength);
|
|
}
|
|
function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) {
|
|
let bestResult = sourceFile;
|
|
let lastNodeEntirelyBeforePosition;
|
|
forEachChild(sourceFile, visit);
|
|
if (lastNodeEntirelyBeforePosition) {
|
|
const lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition);
|
|
if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
|
|
bestResult = lastChildOfLastEntireNodeBeforePosition;
|
|
}
|
|
}
|
|
return bestResult;
|
|
function getLastDescendant(node) {
|
|
while (true) {
|
|
const lastChild = getLastChild(node);
|
|
if (lastChild) {
|
|
node = lastChild;
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function visit(child) {
|
|
if (nodeIsMissing(child)) {
|
|
return;
|
|
}
|
|
if (child.pos <= position) {
|
|
if (child.pos >= bestResult.pos) {
|
|
bestResult = child;
|
|
}
|
|
if (position < child.end) {
|
|
forEachChild(child, visit);
|
|
return true;
|
|
} else {
|
|
Debug.assert(child.end <= position);
|
|
lastNodeEntirelyBeforePosition = child;
|
|
}
|
|
} else {
|
|
Debug.assert(child.pos > position);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) {
|
|
const oldText = sourceFile.text;
|
|
if (textChangeRange) {
|
|
Debug.assert(oldText.length - textChangeRange.span.length + textChangeRange.newLength === newText.length);
|
|
if (aggressiveChecks || Debug.shouldAssert(3 /* VeryAggressive */)) {
|
|
const oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
|
|
const newTextPrefix = newText.substr(0, textChangeRange.span.start);
|
|
Debug.assert(oldTextPrefix === newTextPrefix);
|
|
const oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length);
|
|
const newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length);
|
|
Debug.assert(oldTextSuffix === newTextSuffix);
|
|
}
|
|
}
|
|
}
|
|
function createSyntaxCursor(sourceFile) {
|
|
let currentArray = sourceFile.statements;
|
|
let currentArrayIndex = 0;
|
|
Debug.assert(currentArrayIndex < currentArray.length);
|
|
let current = currentArray[currentArrayIndex];
|
|
let lastQueriedPosition = InvalidPosition.Value;
|
|
return {
|
|
currentNode(position) {
|
|
if (position !== lastQueriedPosition) {
|
|
if (current && current.end === position && currentArrayIndex < currentArray.length - 1) {
|
|
currentArrayIndex++;
|
|
current = currentArray[currentArrayIndex];
|
|
}
|
|
if (!current || current.pos !== position) {
|
|
findHighestListElementThatStartsAtPosition(position);
|
|
}
|
|
}
|
|
lastQueriedPosition = position;
|
|
Debug.assert(!current || current.pos === position);
|
|
return current;
|
|
}
|
|
};
|
|
function findHighestListElementThatStartsAtPosition(position) {
|
|
currentArray = void 0;
|
|
currentArrayIndex = InvalidPosition.Value;
|
|
current = void 0;
|
|
forEachChild(sourceFile, visitNode3, visitArray2);
|
|
return;
|
|
function visitNode3(node) {
|
|
if (position >= node.pos && position < node.end) {
|
|
forEachChild(node, visitNode3, visitArray2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function visitArray2(array) {
|
|
if (position >= array.pos && position < array.end) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const child = array[i];
|
|
if (child) {
|
|
if (child.pos === position) {
|
|
currentArray = array;
|
|
currentArrayIndex = i;
|
|
current = child;
|
|
return true;
|
|
} else {
|
|
if (child.pos < position && position < child.end) {
|
|
forEachChild(child, visitNode3, visitArray2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
IncrementalParser2.createSyntaxCursor = createSyntaxCursor;
|
|
let InvalidPosition;
|
|
((InvalidPosition2) => {
|
|
InvalidPosition2[InvalidPosition2["Value"] = -1] = "Value";
|
|
})(InvalidPosition || (InvalidPosition = {}));
|
|
})(IncrementalParser || (IncrementalParser = {}));
|
|
function isDeclarationFileName(fileName) {
|
|
return fileExtensionIsOneOf(fileName, supportedDeclarationExtensions);
|
|
}
|
|
function parseResolutionMode(mode, pos, end, reportDiagnostic) {
|
|
if (!mode) {
|
|
return void 0;
|
|
}
|
|
if (mode === "import") {
|
|
return 99 /* ESNext */;
|
|
}
|
|
if (mode === "require") {
|
|
return 1 /* CommonJS */;
|
|
}
|
|
reportDiagnostic(pos, end - pos, Diagnostics.resolution_mode_should_be_either_require_or_import);
|
|
return void 0;
|
|
}
|
|
function processCommentPragmas(context, sourceText) {
|
|
const pragmas = [];
|
|
for (const range of getLeadingCommentRanges(sourceText, 0) || emptyArray) {
|
|
const comment = sourceText.substring(range.pos, range.end);
|
|
extractPragmas(pragmas, range, comment);
|
|
}
|
|
context.pragmas = /* @__PURE__ */ new Map();
|
|
for (const pragma of pragmas) {
|
|
if (context.pragmas.has(pragma.name)) {
|
|
const 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);
|
|
}
|
|
}
|
|
function processPragmasIntoFields(context, reportDiagnostic) {
|
|
context.checkJsDirective = void 0;
|
|
context.referencedFiles = [];
|
|
context.typeReferenceDirectives = [];
|
|
context.libReferenceDirectives = [];
|
|
context.amdDependencies = [];
|
|
context.hasNoDefaultLib = false;
|
|
context.pragmas.forEach((entryOrList, key) => {
|
|
switch (key) {
|
|
case "reference": {
|
|
const referencedFiles = context.referencedFiles;
|
|
const typeReferenceDirectives = context.typeReferenceDirectives;
|
|
const libReferenceDirectives = context.libReferenceDirectives;
|
|
forEach(toArray(entryOrList), (arg) => {
|
|
const { types, lib, path, ["resolution-mode"]: res } = arg.arguments;
|
|
if (arg.arguments["no-default-lib"]) {
|
|
context.hasNoDefaultLib = true;
|
|
} else if (types) {
|
|
const parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic);
|
|
typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value, ...parsed ? { resolutionMode: parsed } : {} });
|
|
} else if (lib) {
|
|
libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
|
|
} else if (path) {
|
|
referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value });
|
|
} else {
|
|
reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
case "amd-dependency": {
|
|
context.amdDependencies = map(
|
|
toArray(entryOrList),
|
|
(x) => ({ name: x.arguments.name, path: x.arguments.path })
|
|
);
|
|
break;
|
|
}
|
|
case "amd-module": {
|
|
if (entryOrList instanceof Array) {
|
|
for (const entry of entryOrList) {
|
|
if (context.moduleName) {
|
|
reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, 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": {
|
|
forEach(toArray(entryOrList), (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;
|
|
default:
|
|
Debug.fail("Unhandled pragma kind");
|
|
}
|
|
});
|
|
}
|
|
var namedArgRegExCache = /* @__PURE__ */ new Map();
|
|
function getNamedArgRegEx(name) {
|
|
if (namedArgRegExCache.has(name)) {
|
|
return namedArgRegExCache.get(name);
|
|
}
|
|
const result = new RegExp(`(\\s${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) {
|
|
const tripleSlash = range.kind === 2 /* SingleLineCommentTrivia */ && tripleSlashXMLCommentStartRegEx.exec(text);
|
|
if (tripleSlash) {
|
|
const name = tripleSlash[1].toLowerCase();
|
|
const pragma = commentPragmas[name];
|
|
if (!pragma || !(pragma.kind & 1 /* TripleSlashXML */)) {
|
|
return;
|
|
}
|
|
if (pragma.args) {
|
|
const argument = {};
|
|
for (const arg of pragma.args) {
|
|
const matcher = getNamedArgRegEx(arg.name);
|
|
const matchResult = matcher.exec(text);
|
|
if (!matchResult && !arg.optional) {
|
|
return;
|
|
} else if (matchResult) {
|
|
const value = matchResult[2] || matchResult[3];
|
|
if (arg.captureSpan) {
|
|
const startPos = range.pos + matchResult.index + matchResult[1].length + 1;
|
|
argument[arg.name] = {
|
|
value,
|
|
pos: startPos,
|
|
end: startPos + value.length
|
|
};
|
|
} else {
|
|
argument[arg.name] = value;
|
|
}
|
|
}
|
|
}
|
|
pragmas.push({ name, args: { arguments: argument, range } });
|
|
} else {
|
|
pragmas.push({ name, args: { arguments: {}, range } });
|
|
}
|
|
return;
|
|
}
|
|
const singleLine = range.kind === 2 /* SingleLineCommentTrivia */ && singleLinePragmaRegEx.exec(text);
|
|
if (singleLine) {
|
|
return addPragmaForMatch(pragmas, range, 2 /* SingleLine */, singleLine);
|
|
}
|
|
if (range.kind === 3 /* MultiLineCommentTrivia */) {
|
|
const multiLinePragmaRegEx = /@(\S+)(\s+.*)?$/gim;
|
|
let multiLineMatch;
|
|
while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
|
|
addPragmaForMatch(pragmas, range, 4 /* MultiLine */, multiLineMatch);
|
|
}
|
|
}
|
|
}
|
|
function addPragmaForMatch(pragmas, range, kind, match) {
|
|
if (!match)
|
|
return;
|
|
const name = match[1].toLowerCase();
|
|
const pragma = commentPragmas[name];
|
|
if (!pragma || !(pragma.kind & kind)) {
|
|
return;
|
|
}
|
|
const args = match[2];
|
|
const argument = getNamedPragmaArguments(pragma, args);
|
|
if (argument === "fail")
|
|
return;
|
|
pragmas.push({ name, args: { arguments: argument, range } });
|
|
return;
|
|
}
|
|
function getNamedPragmaArguments(pragma, text) {
|
|
if (!text)
|
|
return {};
|
|
if (!pragma.args)
|
|
return {};
|
|
const args = trimString(text).split(/\s+/);
|
|
const argMap = {};
|
|
for (let i = 0; i < pragma.args.length; i++) {
|
|
const argument = pragma.args[i];
|
|
if (!args[i] && !argument.optional) {
|
|
return "fail";
|
|
}
|
|
if (argument.captureSpan) {
|
|
return Debug.fail("Capture spans not yet implemented for non-xml pragmas");
|
|
}
|
|
argMap[argument.name] = args[i];
|
|
}
|
|
return argMap;
|
|
}
|
|
function tagNamesAreEquivalent(lhs, rhs) {
|
|
if (lhs.kind !== rhs.kind) {
|
|
return false;
|
|
}
|
|
if (lhs.kind === 79 /* Identifier */) {
|
|
return lhs.escapedText === rhs.escapedText;
|
|
}
|
|
if (lhs.kind === 108 /* ThisKeyword */) {
|
|
return true;
|
|
}
|
|
return lhs.name.escapedText === rhs.name.escapedText && tagNamesAreEquivalent(lhs.expression, rhs.expression);
|
|
}
|
|
|
|
// src/compiler/commandLineParser.ts
|
|
var compileOnSaveCommandLineOption = {
|
|
name: "compileOnSave",
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
};
|
|
var jsxOptionMap = new Map(getEntries({
|
|
"preserve": 1 /* Preserve */,
|
|
"react-native": 3 /* ReactNative */,
|
|
"react": 2 /* React */,
|
|
"react-jsx": 4 /* ReactJSX */,
|
|
"react-jsxdev": 5 /* ReactJSXDev */
|
|
}));
|
|
var inverseJsxOptionMap = new Map(arrayFrom(mapIterator(jsxOptionMap.entries(), ([key, value]) => ["" + value, key])));
|
|
var libEntries = [
|
|
["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"],
|
|
["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.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"]
|
|
];
|
|
var libs = libEntries.map((entry) => entry[0]);
|
|
var libMap = new Map(libEntries);
|
|
var optionsForWatch = [
|
|
{
|
|
name: "watchFile",
|
|
type: new Map(getEntries({
|
|
fixedpollinginterval: 0 /* FixedPollingInterval */,
|
|
prioritypollinginterval: 1 /* PriorityPollingInterval */,
|
|
dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
|
|
fixedchunksizepolling: 3 /* FixedChunkSizePolling */,
|
|
usefsevents: 4 /* UseFsEvents */,
|
|
usefseventsonparentdirectory: 5 /* UseFsEventsOnParentDirectory */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_how_the_TypeScript_watch_mode_works,
|
|
defaultValueDescription: 4 /* UseFsEvents */
|
|
},
|
|
{
|
|
name: "watchDirectory",
|
|
type: new Map(getEntries({
|
|
usefsevents: 0 /* UseFsEvents */,
|
|
fixedpollinginterval: 1 /* FixedPollingInterval */,
|
|
dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
|
|
fixedchunksizepolling: 3 /* FixedChunkSizePolling */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality,
|
|
defaultValueDescription: 0 /* UseFsEvents */
|
|
},
|
|
{
|
|
name: "fallbackPolling",
|
|
type: new Map(getEntries({
|
|
fixedinterval: 0 /* FixedInterval */,
|
|
priorityinterval: 1 /* PriorityInterval */,
|
|
dynamicpriority: 2 /* DynamicPriority */,
|
|
fixedchunksize: 3 /* FixedChunkSize */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers,
|
|
defaultValueDescription: 1 /* PriorityInterval */
|
|
},
|
|
{
|
|
name: "synchronousWatchDirectory",
|
|
type: "boolean",
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: 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: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Remove_a_list_of_directories_from_the_watch_process
|
|
},
|
|
{
|
|
name: "excludeFiles",
|
|
type: "list",
|
|
element: {
|
|
name: "excludeFile",
|
|
type: "string",
|
|
isFilePath: true,
|
|
extraValidation: specToDiagnostic
|
|
},
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Remove_a_list_of_files_from_the_watch_mode_s_processing
|
|
}
|
|
];
|
|
var commonOptionsWithBuild = [
|
|
{
|
|
name: "help",
|
|
shortName: "h",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Print_this_message,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "help",
|
|
shortName: "?",
|
|
type: "boolean",
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "watch",
|
|
shortName: "w",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Watch_input_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveWatchOutput",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: false,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Disable_wiping_the_console_in_watch_mode,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_all_of_the_files_read_during_the_compilation,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "explainFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_files_read_during_the_compilation_including_why_it_was_included,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listEmittedFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_the_names_of_emitted_files_after_a_compilation,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "pretty",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read,
|
|
defaultValueDescription: true
|
|
},
|
|
{
|
|
name: "traceResolution",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Log_paths_used_during_the_moduleResolution_process,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "diagnostics",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Output_compiler_performance_information_after_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "extendedDiagnostics",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Output_more_detailed_compiler_performance_information_after_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "generateCpuProfile",
|
|
type: "string",
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE_OR_DIRECTORY,
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging,
|
|
defaultValueDescription: "profile.cpuprofile"
|
|
},
|
|
{
|
|
name: "generateTrace",
|
|
type: "string",
|
|
isFilePath: true,
|
|
isCommandLineOnly: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Generates_an_event_trace_and_a_list_of_types
|
|
},
|
|
{
|
|
name: "incremental",
|
|
shortName: "i",
|
|
type: "boolean",
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: Diagnostics.false_unless_composite_is_set
|
|
},
|
|
{
|
|
name: "declaration",
|
|
shortName: "d",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project,
|
|
defaultValueDescription: Diagnostics.false_unless_composite_is_set
|
|
},
|
|
{
|
|
name: "declarationMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Create_sourcemaps_for_d_ts_files
|
|
},
|
|
{
|
|
name: "emitDeclarationOnly",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "sourceMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Create_source_map_files_for_emitted_JavaScript_files
|
|
},
|
|
{
|
|
name: "inlineSourceMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "assumeChangesOnlyAffectDirectDependencies",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: 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: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit,
|
|
defaultValueDescription: Diagnostics.Platform_specific
|
|
}
|
|
];
|
|
var targetOptionDeclaration = {
|
|
name: "target",
|
|
shortName: "t",
|
|
type: new Map(getEntries({
|
|
es3: 0 /* ES3 */,
|
|
es5: 1 /* ES5 */,
|
|
es6: 2 /* ES2015 */,
|
|
es2015: 2 /* ES2015 */,
|
|
es2016: 3 /* ES2016 */,
|
|
es2017: 4 /* ES2017 */,
|
|
es2018: 5 /* ES2018 */,
|
|
es2019: 6 /* ES2019 */,
|
|
es2020: 7 /* ES2020 */,
|
|
es2021: 8 /* ES2021 */,
|
|
es2022: 9 /* ES2022 */,
|
|
esnext: 99 /* ESNext */
|
|
})),
|
|
affectsSourceFile: true,
|
|
affectsModuleResolution: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.VERSION,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
|
|
defaultValueDescription: 0 /* ES3 */
|
|
};
|
|
var moduleOptionDeclaration = {
|
|
name: "module",
|
|
shortName: "m",
|
|
type: new Map(getEntries({
|
|
none: 0 /* None */,
|
|
commonjs: 1 /* CommonJS */,
|
|
amd: 2 /* AMD */,
|
|
system: 4 /* System */,
|
|
umd: 3 /* UMD */,
|
|
es6: 5 /* ES2015 */,
|
|
es2015: 5 /* ES2015 */,
|
|
es2020: 6 /* ES2020 */,
|
|
es2022: 7 /* ES2022 */,
|
|
esnext: 99 /* ESNext */,
|
|
node16: 100 /* Node16 */,
|
|
nodenext: 199 /* NodeNext */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.KIND,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_what_module_code_is_generated,
|
|
defaultValueDescription: void 0
|
|
};
|
|
var commandOptionsWithoutBuild = [
|
|
{
|
|
name: "all",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Show_all_compiler_options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "version",
|
|
shortName: "v",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Print_the_compiler_s_version,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "init",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "project",
|
|
shortName: "p",
|
|
type: "string",
|
|
isFilePath: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
paramType: Diagnostics.FILE_OR_DIRECTORY,
|
|
description: 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: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "showConfig",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Print_the_final_configuration_instead_of_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listFilesOnly",
|
|
type: "boolean",
|
|
category: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
|
|
defaultValueDescription: false
|
|
},
|
|
targetOptionDeclaration,
|
|
moduleOptionDeclaration,
|
|
{
|
|
name: "lib",
|
|
type: "list",
|
|
element: {
|
|
name: "lib",
|
|
type: libMap,
|
|
defaultValueDescription: void 0
|
|
},
|
|
affectsProgramStructure: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "allowJs",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.JavaScript_Support,
|
|
description: 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: Diagnostics.JavaScript_Support,
|
|
description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "jsx",
|
|
type: jsxOptionMap,
|
|
affectsSourceFile: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsModuleResolution: true,
|
|
paramType: Diagnostics.KIND,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_what_JSX_code_is_generated,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "outFile",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: 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: void 0
|
|
},
|
|
{
|
|
name: "outDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_an_output_folder_for_all_emitted_files
|
|
},
|
|
{
|
|
name: "rootDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_the_root_folder_within_your_source_files,
|
|
defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files
|
|
},
|
|
{
|
|
name: "composite",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references
|
|
},
|
|
{
|
|
name: "tsBuildInfoFile",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE,
|
|
category: Diagnostics.Projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: ".tsbuildinfo",
|
|
description: Diagnostics.Specify_the_path_to_tsbuildinfo_incremental_compilation_file
|
|
},
|
|
{
|
|
name: "removeComments",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Disable_emitting_comments
|
|
},
|
|
{
|
|
name: "noEmit",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_emitting_files_from_a_compilation,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "importHelpers",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "importsNotUsedAsValues",
|
|
type: new Map(getEntries({
|
|
remove: 0 /* Remove */,
|
|
preserve: 1 /* Preserve */,
|
|
error: 2 /* Error */
|
|
})),
|
|
affectsEmit: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types,
|
|
defaultValueDescription: 0 /* Remove */
|
|
},
|
|
{
|
|
name: "downlevelIteration",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "isolatedModules",
|
|
type: "boolean",
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "strict",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_all_strict_type_checking_options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitAny",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictNullChecks",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.When_type_checking_take_into_account_null_and_undefined,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictFunctionTypes",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictBindCallApply",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictPropertyInitialization",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "noImplicitThis",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "useUnknownInCatchVariables",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "alwaysStrict",
|
|
type: "boolean",
|
|
affectsSourceFile: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Ensure_use_strict_is_always_emitted,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "noUnusedLocals",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noUnusedParameters",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "exactOptionalPropertyTypes",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitReturns",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noFallthroughCasesInSwitch",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noUncheckedIndexedAccess",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitOverride",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noPropertyAccessFromIndexSignature",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: false,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "moduleResolution",
|
|
type: new Map(getEntries({
|
|
node: 2 /* NodeJs */,
|
|
classic: 1 /* Classic */,
|
|
node16: 3 /* Node16 */,
|
|
nodenext: 99 /* NodeNext */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
paramType: Diagnostics.STRATEGY,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier,
|
|
defaultValueDescription: Diagnostics.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node
|
|
},
|
|
{
|
|
name: "baseUrl",
|
|
type: "string",
|
|
affectsModuleResolution: true,
|
|
isFilePath: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_the_base_directory_to_resolve_non_relative_module_names
|
|
},
|
|
{
|
|
name: "paths",
|
|
type: "object",
|
|
affectsModuleResolution: true,
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "rootDirs",
|
|
type: "list",
|
|
isTSConfigOnly: true,
|
|
element: {
|
|
name: "rootDirs",
|
|
type: "string",
|
|
isFilePath: true
|
|
},
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files
|
|
},
|
|
{
|
|
name: "typeRoots",
|
|
type: "list",
|
|
element: {
|
|
name: "typeRoots",
|
|
type: "string",
|
|
isFilePath: true
|
|
},
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: 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: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "allowSyntheticDefaultImports",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
|
|
defaultValueDescription: Diagnostics.module_system_or_esModuleInterop
|
|
},
|
|
{
|
|
name: "esModuleInterop",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveSymlinks",
|
|
type: "boolean",
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "allowUmdGlobalAccess",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Allow_accessing_UMD_globals_from_modules,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "moduleSuffixes",
|
|
type: "list",
|
|
element: {
|
|
name: "suffix",
|
|
type: "string"
|
|
},
|
|
listPreserveFalsyValues: true,
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module
|
|
},
|
|
{
|
|
name: "sourceRoot",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code
|
|
},
|
|
{
|
|
name: "mapRoot",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations
|
|
},
|
|
{
|
|
name: "inlineSources",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "experimentalDecorators",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Enable_experimental_support_for_TC39_stage_2_draft_decorators,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "emitDecoratorMetadata",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "jsxFactory",
|
|
type: "string",
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: 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: Diagnostics.Language_and_Environment,
|
|
description: 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,
|
|
affectsBuildInfo: true,
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: 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: Diagnostics.Modules,
|
|
description: Diagnostics.Enable_importing_json_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "out",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: false,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
paramType: Diagnostics.FILE,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Deprecated_setting_Use_outFile_instead
|
|
},
|
|
{
|
|
name: "reactNamespace",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit,
|
|
defaultValueDescription: "`React`"
|
|
},
|
|
{
|
|
name: "skipDefaultLibCheck",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Completeness,
|
|
description: Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "charset",
|
|
type: "string",
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files,
|
|
defaultValueDescription: "utf8"
|
|
},
|
|
{
|
|
name: "emitBOM",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "newLine",
|
|
type: new Map(getEntries({
|
|
crlf: 0 /* CarriageReturnLineFeed */,
|
|
lf: 1 /* LineFeed */
|
|
})),
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.NEWLINE,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Set_the_newline_character_for_emitting_files,
|
|
defaultValueDescription: Diagnostics.Platform_specific
|
|
},
|
|
{
|
|
name: "noErrorTruncation",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Disable_truncating_types_in_error_messages,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noLib",
|
|
type: "boolean",
|
|
category: Diagnostics.Language_and_Environment,
|
|
affectsProgramStructure: true,
|
|
description: Diagnostics.Disable_including_any_library_files_including_the_default_lib_d_ts,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noResolve",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "stripInternal",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableSizeLimit",
|
|
type: "boolean",
|
|
affectsProgramStructure: true,
|
|
category: Diagnostics.Editor_Support,
|
|
description: 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: Diagnostics.Projects,
|
|
description: Diagnostics.Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableSolutionSearching",
|
|
type: "boolean",
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Opt_a_project_out_of_multi_project_reference_checking_when_editing,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableReferencedProjectLoad",
|
|
type: "boolean",
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Reduce_the_number_of_projects_loaded_automatically_by_TypeScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitUseStrict",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noEmitHelpers",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noEmitOnError",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveConstEnums",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "declarationDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Specify_the_output_directory_for_generated_declaration_files
|
|
},
|
|
{
|
|
name: "skipLibCheck",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Completeness,
|
|
description: Diagnostics.Skip_type_checking_all_d_ts_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "allowUnusedLabels",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Disable_error_reporting_for_unused_labels,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "allowUnreachableCode",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Disable_error_reporting_for_unreachable_code,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "suppressExcessPropertyErrors",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "suppressImplicitAnyIndexErrors",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "forceConsistentCasingInFileNames",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Ensure_that_casing_is_correct_in_imports,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "maxNodeModuleJsDepth",
|
|
type: "number",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.JavaScript_Support,
|
|
description: 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,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "useDefineForClassFields",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
|
|
defaultValueDescription: Diagnostics.true_for_ES2022_and_above_including_ESNext
|
|
},
|
|
{
|
|
name: "preserveValueImports",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "keyofStringsOnly",
|
|
type: "boolean",
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "plugins",
|
|
type: "list",
|
|
isTSConfigOnly: true,
|
|
element: {
|
|
name: "plugin",
|
|
type: "object"
|
|
},
|
|
description: Diagnostics.Specify_a_list_of_language_service_plugins_to_include,
|
|
category: Diagnostics.Editor_Support
|
|
},
|
|
{
|
|
name: "moduleDetection",
|
|
type: new Map(getEntries({
|
|
auto: 2 /* Auto */,
|
|
legacy: 1 /* Legacy */,
|
|
force: 3 /* Force */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
description: Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
|
|
category: Diagnostics.Language_and_Environment,
|
|
defaultValueDescription: 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
|
|
}
|
|
];
|
|
var optionDeclarations = [
|
|
...commonOptionsWithBuild,
|
|
...commandOptionsWithoutBuild
|
|
];
|
|
var semanticDiagnosticsOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsSemanticDiagnostics);
|
|
var affectsEmitOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsEmit);
|
|
var affectsDeclarationPathOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsDeclarationPath);
|
|
var moduleResolutionOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsModuleResolution);
|
|
var sourceFileAffectingCompilerOptions = optionDeclarations.filter((option) => !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics);
|
|
var optionsAffectingProgramStructure = optionDeclarations.filter((option) => !!option.affectsProgramStructure);
|
|
var transpileOptionValueCompilerOptions = optionDeclarations.filter((option) => hasProperty(option, "transpileOptionValue"));
|
|
var optionsForBuild = [
|
|
{
|
|
name: "verbose",
|
|
shortName: "v",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Enable_verbose_logging,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "dry",
|
|
shortName: "d",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "force",
|
|
shortName: "f",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "clean",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Delete_the_outputs_of_all_projects,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
}
|
|
];
|
|
var buildOpts = [
|
|
...commonOptionsWithBuild,
|
|
...optionsForBuild
|
|
];
|
|
var typeAcquisitionDeclarations = [
|
|
{
|
|
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
|
|
}
|
|
];
|
|
function createOptionNameMap(optionDeclarations2) {
|
|
const optionsNameMap = /* @__PURE__ */ new Map();
|
|
const shortOptionNames = /* @__PURE__ */ new Map();
|
|
forEach(optionDeclarations2, (option) => {
|
|
optionsNameMap.set(option.name.toLowerCase(), option);
|
|
if (option.shortName) {
|
|
shortOptionNames.set(option.shortName, option.name);
|
|
}
|
|
});
|
|
return { optionsNameMap, shortOptionNames };
|
|
}
|
|
var optionsNameMapCache;
|
|
function getOptionsNameMap() {
|
|
return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(optionDeclarations));
|
|
}
|
|
var compilerOptionsAlternateMode = {
|
|
diagnostic: Diagnostics.Compiler_option_0_may_only_be_used_with_build,
|
|
getOptionsNameMap: getBuildOptionsNameMap
|
|
};
|
|
var defaultInitCompilerOptions = {
|
|
module: 1 /* CommonJS */,
|
|
target: 3 /* ES2016 */,
|
|
strict: true,
|
|
esModuleInterop: true,
|
|
forceConsistentCasingInFileNames: true,
|
|
skipLibCheck: true
|
|
};
|
|
function convertEnableAutoDiscoveryToEnable(typeAcquisition) {
|
|
if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== void 0 && typeAcquisition.enable === void 0) {
|
|
return {
|
|
enable: typeAcquisition.enableAutoDiscovery,
|
|
include: typeAcquisition.include || [],
|
|
exclude: typeAcquisition.exclude || []
|
|
};
|
|
}
|
|
return typeAcquisition;
|
|
}
|
|
function createCompilerDiagnosticForInvalidCustomType(opt) {
|
|
return createDiagnosticForInvalidCustomType(opt, createCompilerDiagnostic);
|
|
}
|
|
function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
|
|
const namesOfType = arrayFrom(opt.type.keys()).map((key) => `'${key}'`).join(", ");
|
|
return createDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
|
|
}
|
|
function parseCustomTypeOption(opt, value, errors) {
|
|
return convertJsonOptionOfCustomType(opt, trimString(value || ""), errors);
|
|
}
|
|
function parseListTypeOption(opt, value = "", errors) {
|
|
value = trimString(value);
|
|
if (startsWith(value, "-")) {
|
|
return void 0;
|
|
}
|
|
if (value === "") {
|
|
return [];
|
|
}
|
|
const values = value.split(",");
|
|
switch (opt.element.type) {
|
|
case "number":
|
|
return mapDefined(values, (v) => validateJsonOptionValue(opt.element, parseInt(v), errors));
|
|
case "string":
|
|
return mapDefined(values, (v) => validateJsonOptionValue(opt.element, v || "", errors));
|
|
default:
|
|
return mapDefined(values, (v) => parseCustomTypeOption(opt.element, v, errors));
|
|
}
|
|
}
|
|
function getOptionName(option) {
|
|
return option.name;
|
|
}
|
|
function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
|
|
var _a2;
|
|
if ((_a2 = diagnostics.alternateMode) == null ? void 0 : _a2.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) {
|
|
return createDiagnostics(diagnostics.alternateMode.diagnostic, unknownOption);
|
|
}
|
|
const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
|
|
return possibleOption ? createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
|
|
}
|
|
function parseCommandLineWorker(diagnostics, commandLine, readFile) {
|
|
const options = {};
|
|
let watchOptions;
|
|
const fileNames = [];
|
|
const errors = [];
|
|
parseStrings(commandLine);
|
|
return {
|
|
options,
|
|
watchOptions,
|
|
fileNames,
|
|
errors
|
|
};
|
|
function parseStrings(args) {
|
|
let i = 0;
|
|
while (i < args.length) {
|
|
const s = args[i];
|
|
i++;
|
|
if (s.charCodeAt(0) === 64 /* at */) {
|
|
parseResponseFile(s.slice(1));
|
|
} else if (s.charCodeAt(0) === 45 /* minus */) {
|
|
const inputOptionName = s.slice(s.charCodeAt(1) === 45 /* minus */ ? 2 : 1);
|
|
const opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, true);
|
|
if (opt) {
|
|
i = parseOptionValue(args, i, diagnostics, opt, options, errors);
|
|
} else {
|
|
const watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, true);
|
|
if (watchOpt) {
|
|
i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
|
|
} else {
|
|
errors.push(createUnknownOptionError(inputOptionName, diagnostics, createCompilerDiagnostic, s));
|
|
}
|
|
}
|
|
} else {
|
|
fileNames.push(s);
|
|
}
|
|
}
|
|
}
|
|
function parseResponseFile(fileName) {
|
|
const text = tryReadFile(fileName, readFile || ((fileName2) => sys.readFile(fileName2)));
|
|
if (!isString(text)) {
|
|
errors.push(text);
|
|
return;
|
|
}
|
|
const args = [];
|
|
let pos = 0;
|
|
while (true) {
|
|
while (pos < text.length && text.charCodeAt(pos) <= 32 /* space */)
|
|
pos++;
|
|
if (pos >= text.length)
|
|
break;
|
|
const start = pos;
|
|
if (text.charCodeAt(start) === 34 /* doubleQuote */) {
|
|
pos++;
|
|
while (pos < text.length && text.charCodeAt(pos) !== 34 /* doubleQuote */)
|
|
pos++;
|
|
if (pos < text.length) {
|
|
args.push(text.substring(start + 1, pos));
|
|
pos++;
|
|
} else {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
|
|
}
|
|
} else {
|
|
while (text.charCodeAt(pos) > 32 /* space */)
|
|
pos++;
|
|
args.push(text.substring(start, pos));
|
|
}
|
|
}
|
|
parseStrings(args);
|
|
}
|
|
}
|
|
function parseOptionValue(args, i, diagnostics, opt, options, errors) {
|
|
if (opt.isTSConfigOnly) {
|
|
const optValue = args[i];
|
|
if (optValue === "null") {
|
|
options[opt.name] = void 0;
|
|
i++;
|
|
} else if (opt.type === "boolean") {
|
|
if (optValue === "false") {
|
|
options[opt.name] = validateJsonOptionValue(opt, false, errors);
|
|
i++;
|
|
} else {
|
|
if (optValue === "true")
|
|
i++;
|
|
errors.push(createCompilerDiagnostic(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(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name));
|
|
if (optValue && !startsWith(optValue, "-"))
|
|
i++;
|
|
}
|
|
} else {
|
|
if (!args[i] && opt.type !== "boolean") {
|
|
errors.push(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":
|
|
const optValue = args[i];
|
|
options[opt.name] = validateJsonOptionValue(opt, optValue !== "false", errors);
|
|
if (optValue === "false" || optValue === "true") {
|
|
i++;
|
|
}
|
|
break;
|
|
case "string":
|
|
options[opt.name] = validateJsonOptionValue(opt, args[i] || "", errors);
|
|
i++;
|
|
break;
|
|
case "list":
|
|
const result = parseListTypeOption(opt, args[i], errors);
|
|
options[opt.name] = result || [];
|
|
if (result) {
|
|
i++;
|
|
}
|
|
break;
|
|
default:
|
|
options[opt.name] = parseCustomTypeOption(opt, args[i], errors);
|
|
i++;
|
|
break;
|
|
}
|
|
} else {
|
|
options[opt.name] = void 0;
|
|
i++;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
var compilerOptionsDidYouMeanDiagnostics = {
|
|
alternateMode: compilerOptionsAlternateMode,
|
|
getOptionsNameMap,
|
|
optionDeclarations,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_compiler_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
|
|
};
|
|
function parseCommandLine(commandLine, readFile) {
|
|
return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
|
|
}
|
|
function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort = false) {
|
|
optionName = optionName.toLowerCase();
|
|
const { optionsNameMap, shortOptionNames } = getOptionNameMap();
|
|
if (allowShort) {
|
|
const short = shortOptionNames.get(optionName);
|
|
if (short !== void 0) {
|
|
optionName = short;
|
|
}
|
|
}
|
|
return optionsNameMap.get(optionName);
|
|
}
|
|
var buildOptionsNameMapCache;
|
|
function getBuildOptionsNameMap() {
|
|
return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(buildOpts));
|
|
}
|
|
var buildOptionsAlternateMode = {
|
|
diagnostic: Diagnostics.Compiler_option_0_may_not_be_used_with_build,
|
|
getOptionsNameMap
|
|
};
|
|
var buildOptionsDidYouMeanDiagnostics = {
|
|
alternateMode: buildOptionsAlternateMode,
|
|
getOptionsNameMap: getBuildOptionsNameMap,
|
|
optionDeclarations: buildOpts,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_build_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_build_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Build_option_0_requires_a_value_of_type_1
|
|
};
|
|
function parseBuildCommand(args) {
|
|
const { options, watchOptions, fileNames: projects, errors } = parseCommandLineWorker(
|
|
buildOptionsDidYouMeanDiagnostics,
|
|
args
|
|
);
|
|
const buildOptions = options;
|
|
if (projects.length === 0) {
|
|
projects.push(".");
|
|
}
|
|
if (buildOptions.clean && buildOptions.force) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force"));
|
|
}
|
|
if (buildOptions.clean && buildOptions.verbose) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose"));
|
|
}
|
|
if (buildOptions.clean && buildOptions.watch) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch"));
|
|
}
|
|
if (buildOptions.watch && buildOptions.dry) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry"));
|
|
}
|
|
return { buildOptions, watchOptions, projects, errors };
|
|
}
|
|
function getDiagnosticText(_message, ..._args) {
|
|
const diagnostic = createCompilerDiagnostic.apply(void 0, arguments);
|
|
return diagnostic.messageText;
|
|
}
|
|
function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) {
|
|
const configFileText = tryReadFile(configFileName, (fileName) => host.readFile(fileName));
|
|
if (!isString(configFileText)) {
|
|
host.onUnRecoverableConfigFileDiagnostic(configFileText);
|
|
return void 0;
|
|
}
|
|
const result = parseJsonText(configFileName, configFileText);
|
|
const cwd = host.getCurrentDirectory();
|
|
result.path = toPath(configFileName, cwd, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
|
|
result.resolvedPath = result.path;
|
|
result.originalFileName = result.fileName;
|
|
return parseJsonSourceFileConfigFileContent(
|
|
result,
|
|
host,
|
|
getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd),
|
|
optionsToExtend,
|
|
getNormalizedAbsolutePath(configFileName, cwd),
|
|
void 0,
|
|
extraFileExtensions,
|
|
extendedConfigCache,
|
|
watchOptionsToExtend
|
|
);
|
|
}
|
|
function parseConfigFileTextToJson(fileName, jsonText) {
|
|
const jsonSourceFile = parseJsonText(fileName, jsonText);
|
|
return {
|
|
config: convertConfigFileToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics, false, void 0),
|
|
error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
|
|
};
|
|
}
|
|
function readJsonConfigFile(fileName, readFile) {
|
|
const textOrDiagnostic = tryReadFile(fileName, readFile);
|
|
return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
|
|
}
|
|
function tryReadFile(fileName, readFile) {
|
|
let text;
|
|
try {
|
|
text = readFile(fileName);
|
|
} catch (e) {
|
|
return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
|
|
}
|
|
return text === void 0 ? createCompilerDiagnostic(Diagnostics.Cannot_read_file_0, fileName) : text;
|
|
}
|
|
function commandLineOptionsToMap(options) {
|
|
return arrayToMap(options, getOptionName);
|
|
}
|
|
var typeAcquisitionDidYouMeanDiagnostics = {
|
|
optionDeclarations: typeAcquisitionDeclarations,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_type_acquisition_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1
|
|
};
|
|
var watchOptionsNameMapCache;
|
|
function getWatchOptionsNameMap() {
|
|
return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(optionsForWatch));
|
|
}
|
|
var watchOptionsDidYouMeanDiagnostics = {
|
|
getOptionsNameMap: getWatchOptionsNameMap,
|
|
optionDeclarations: optionsForWatch,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_watch_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_watch_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Watch_option_0_requires_a_value_of_type_1
|
|
};
|
|
var commandLineCompilerOptionsMapCache;
|
|
function getCommandLineCompilerOptionsMap() {
|
|
return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(optionDeclarations));
|
|
}
|
|
var commandLineWatchOptionsMapCache;
|
|
function getCommandLineWatchOptionsMap() {
|
|
return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(optionsForWatch));
|
|
}
|
|
var commandLineTypeAcquisitionMapCache;
|
|
function getCommandLineTypeAcquisitionMap() {
|
|
return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(typeAcquisitionDeclarations));
|
|
}
|
|
var _tsconfigRootOptions;
|
|
function getTsconfigRootOptionsMap() {
|
|
if (_tsconfigRootOptions === void 0) {
|
|
_tsconfigRootOptions = {
|
|
name: void 0,
|
|
type: "object",
|
|
elementOptions: commandLineOptionsToMap([
|
|
{
|
|
name: "compilerOptions",
|
|
type: "object",
|
|
elementOptions: getCommandLineCompilerOptionsMap(),
|
|
extraKeyDiagnostics: 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: Diagnostics.File_Management
|
|
},
|
|
{
|
|
name: "references",
|
|
type: "list",
|
|
element: {
|
|
name: "references",
|
|
type: "object"
|
|
},
|
|
category: Diagnostics.Projects
|
|
},
|
|
{
|
|
name: "files",
|
|
type: "list",
|
|
element: {
|
|
name: "files",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management
|
|
},
|
|
{
|
|
name: "include",
|
|
type: "list",
|
|
element: {
|
|
name: "include",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management,
|
|
defaultValueDescription: Diagnostics.if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk
|
|
},
|
|
{
|
|
name: "exclude",
|
|
type: "list",
|
|
element: {
|
|
name: "exclude",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management,
|
|
defaultValueDescription: Diagnostics.node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified
|
|
},
|
|
compileOnSaveCommandLineOption
|
|
])
|
|
};
|
|
}
|
|
return _tsconfigRootOptions;
|
|
}
|
|
function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, optionsIterator) {
|
|
var _a2;
|
|
const rootExpression = (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression;
|
|
const knownRootOptions = reportOptionsErrors ? getTsconfigRootOptionsMap() : void 0;
|
|
if (rootExpression && rootExpression.kind !== 207 /* ObjectLiteralExpression */) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(
|
|
sourceFile,
|
|
rootExpression,
|
|
Diagnostics.The_root_value_of_a_0_file_must_be_an_object,
|
|
getBaseFileName(sourceFile.fileName) === "jsconfig.json" ? "jsconfig.json" : "tsconfig.json"
|
|
));
|
|
if (isArrayLiteralExpression(rootExpression)) {
|
|
const firstObject = find(rootExpression.elements, isObjectLiteralExpression);
|
|
if (firstObject) {
|
|
return convertToObjectWorker(sourceFile, firstObject, errors, true, knownRootOptions, optionsIterator);
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
return convertToObjectWorker(sourceFile, rootExpression, errors, true, knownRootOptions, optionsIterator);
|
|
}
|
|
function convertToObject(sourceFile, errors) {
|
|
var _a2;
|
|
return convertToObjectWorker(sourceFile, (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression, errors, true, void 0, void 0);
|
|
}
|
|
function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
|
|
if (!rootExpression) {
|
|
return returnValue ? {} : void 0;
|
|
}
|
|
return convertPropertyValueToJson(rootExpression, knownRootOptions);
|
|
function isRootOptionMap(knownOptions) {
|
|
return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
|
|
}
|
|
function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
|
|
const result = returnValue ? {} : void 0;
|
|
for (const element of node.properties) {
|
|
if (element.kind !== 299 /* PropertyAssignment */) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element, Diagnostics.Property_assignment_expected));
|
|
continue;
|
|
}
|
|
if (element.questionToken) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
|
|
}
|
|
if (!isDoubleQuotedString(element.name)) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, Diagnostics.String_literal_with_double_quotes_expected));
|
|
}
|
|
const textOfKey = isComputedNonLiteralName(element.name) ? void 0 : getTextOfPropertyName(element.name);
|
|
const keyText = textOfKey && unescapeLeadingUnderscores(textOfKey);
|
|
const option = keyText && knownOptions ? knownOptions.get(keyText) : void 0;
|
|
if (keyText && extraKeyDiagnostics && !option) {
|
|
if (knownOptions) {
|
|
errors.push(createUnknownOptionError(
|
|
keyText,
|
|
extraKeyDiagnostics,
|
|
(message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1)
|
|
));
|
|
} else {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
|
|
}
|
|
}
|
|
const value = convertPropertyValueToJson(element.initializer, option);
|
|
if (typeof keyText !== "undefined") {
|
|
if (returnValue) {
|
|
result[keyText] = value;
|
|
}
|
|
if (jsonConversionNotifier && (parentOption || isRootOptionMap(knownOptions))) {
|
|
const isValidOptionValue = isCompilerOptionsValue(option, value);
|
|
if (parentOption) {
|
|
if (isValidOptionValue) {
|
|
jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value);
|
|
}
|
|
} else if (isRootOptionMap(knownOptions)) {
|
|
if (isValidOptionValue) {
|
|
jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
|
|
} else if (!option) {
|
|
jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function convertArrayLiteralExpressionToJson(elements, elementOption) {
|
|
if (!returnValue) {
|
|
elements.forEach((element) => convertPropertyValueToJson(element, elementOption));
|
|
return void 0;
|
|
}
|
|
return filter(elements.map((element) => convertPropertyValueToJson(element, elementOption)), (v) => v !== void 0);
|
|
}
|
|
function convertPropertyValueToJson(valueExpression, option) {
|
|
let invalidReported;
|
|
switch (valueExpression.kind) {
|
|
case 110 /* TrueKeyword */:
|
|
reportInvalidOptionValue(option && option.type !== "boolean");
|
|
return validateValue(true);
|
|
case 95 /* FalseKeyword */:
|
|
reportInvalidOptionValue(option && option.type !== "boolean");
|
|
return validateValue(false);
|
|
case 104 /* NullKeyword */:
|
|
reportInvalidOptionValue(option && option.name === "extends");
|
|
return validateValue(null);
|
|
case 10 /* StringLiteral */:
|
|
if (!isDoubleQuotedString(valueExpression)) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
|
|
}
|
|
reportInvalidOptionValue(option && (isString(option.type) && option.type !== "string"));
|
|
const text = valueExpression.text;
|
|
if (option && !isString(option.type)) {
|
|
const customOption = option;
|
|
if (!customOption.type.has(text.toLowerCase())) {
|
|
errors.push(
|
|
createDiagnosticForInvalidCustomType(
|
|
customOption,
|
|
(message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1)
|
|
)
|
|
);
|
|
invalidReported = true;
|
|
}
|
|
}
|
|
return validateValue(text);
|
|
case 8 /* NumericLiteral */:
|
|
reportInvalidOptionValue(option && option.type !== "number");
|
|
return validateValue(Number(valueExpression.text));
|
|
case 221 /* PrefixUnaryExpression */:
|
|
if (valueExpression.operator !== 40 /* MinusToken */ || valueExpression.operand.kind !== 8 /* NumericLiteral */) {
|
|
break;
|
|
}
|
|
reportInvalidOptionValue(option && option.type !== "number");
|
|
return validateValue(-Number(valueExpression.operand.text));
|
|
case 207 /* ObjectLiteralExpression */:
|
|
reportInvalidOptionValue(option && option.type !== "object");
|
|
const objectLiteralExpression = valueExpression;
|
|
if (option) {
|
|
const { elementOptions, extraKeyDiagnostics, name: optionName } = option;
|
|
return validateValue(convertObjectLiteralExpressionToJson(
|
|
objectLiteralExpression,
|
|
elementOptions,
|
|
extraKeyDiagnostics,
|
|
optionName
|
|
));
|
|
} else {
|
|
return validateValue(convertObjectLiteralExpressionToJson(
|
|
objectLiteralExpression,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
));
|
|
}
|
|
case 206 /* ArrayLiteralExpression */:
|
|
reportInvalidOptionValue(option && option.type !== "list");
|
|
return validateValue(convertArrayLiteralExpressionToJson(
|
|
valueExpression.elements,
|
|
option && option.element
|
|
));
|
|
}
|
|
if (option) {
|
|
reportInvalidOptionValue(true);
|
|
} else {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
|
|
}
|
|
return void 0;
|
|
function validateValue(value) {
|
|
var _a2;
|
|
if (!invalidReported) {
|
|
const diagnostic = (_a2 = option == null ? void 0 : option.extraValidation) == null ? void 0 : _a2.call(option, value);
|
|
if (diagnostic) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ...diagnostic));
|
|
return void 0;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function reportInvalidOptionValue(isError) {
|
|
if (isError) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
|
|
invalidReported = true;
|
|
}
|
|
}
|
|
}
|
|
function isDoubleQuotedString(node) {
|
|
return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
|
|
}
|
|
}
|
|
function getCompilerOptionValueTypeString(option) {
|
|
return option.type === "list" ? "Array" : isString(option.type) ? option.type : "string";
|
|
}
|
|
function isCompilerOptionsValue(option, value) {
|
|
if (option) {
|
|
if (isNullOrUndefined(value))
|
|
return true;
|
|
if (option.type === "list") {
|
|
return isArray(value);
|
|
}
|
|
const expectedType = isString(option.type) ? option.type : "string";
|
|
return typeof value === expectedType;
|
|
}
|
|
return false;
|
|
}
|
|
function convertToTSConfig(configParseResult, configFileName, host) {
|
|
var _a2, _b, _c;
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
|
|
const files = map(
|
|
filter(
|
|
configParseResult.fileNames,
|
|
!((_b = (_a2 = configParseResult.options.configFile) == null ? void 0 : _a2.configFileSpecs) == null ? void 0 : _b.validatedIncludeSpecs) ? returnTrue : matchesSpecs(
|
|
configFileName,
|
|
configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs,
|
|
configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs,
|
|
host
|
|
)
|
|
),
|
|
(f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
|
|
);
|
|
const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
|
|
const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
|
|
const config = {
|
|
compilerOptions: {
|
|
...optionMapToObject(optionMap),
|
|
showConfig: void 0,
|
|
configFile: void 0,
|
|
configFilePath: void 0,
|
|
help: void 0,
|
|
init: void 0,
|
|
listFiles: void 0,
|
|
listEmittedFiles: void 0,
|
|
project: void 0,
|
|
build: void 0,
|
|
version: void 0
|
|
},
|
|
watchOptions: watchOptionMap && optionMapToObject(watchOptionMap),
|
|
references: map(configParseResult.projectReferences, (r) => ({ ...r, path: r.originalPath ? r.originalPath : "", originalPath: void 0 })),
|
|
files: length(files) ? files : void 0,
|
|
...((_c = configParseResult.options.configFile) == null ? void 0 : _c.configFileSpecs) ? {
|
|
include: filterSameAsDefaultInclude(configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs),
|
|
exclude: configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs
|
|
} : {},
|
|
compileOnSave: !!configParseResult.compileOnSave ? true : void 0
|
|
};
|
|
return config;
|
|
}
|
|
function optionMapToObject(optionMap) {
|
|
return {
|
|
...arrayFrom(optionMap.entries()).reduce((prev, cur) => ({ ...prev, [cur[0]]: cur[1] }), {})
|
|
};
|
|
}
|
|
function filterSameAsDefaultInclude(specs) {
|
|
if (!length(specs))
|
|
return void 0;
|
|
if (length(specs) !== 1)
|
|
return specs;
|
|
if (specs[0] === defaultIncludeSpec)
|
|
return void 0;
|
|
return specs;
|
|
}
|
|
function matchesSpecs(path, includeSpecs, excludeSpecs, host) {
|
|
if (!includeSpecs)
|
|
return returnTrue;
|
|
const patterns = getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
|
|
const excludeRe = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
|
|
const includeRe = patterns.includeFilePattern && getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
|
|
if (includeRe) {
|
|
if (excludeRe) {
|
|
return (path2) => !(includeRe.test(path2) && !excludeRe.test(path2));
|
|
}
|
|
return (path2) => !includeRe.test(path2);
|
|
}
|
|
if (excludeRe) {
|
|
return (path2) => excludeRe.test(path2);
|
|
}
|
|
return returnTrue;
|
|
}
|
|
function getCustomTypeMapOfCommandLineOption(optionDefinition) {
|
|
if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") {
|
|
return void 0;
|
|
} else if (optionDefinition.type === "list") {
|
|
return getCustomTypeMapOfCommandLineOption(optionDefinition.element);
|
|
} else {
|
|
return optionDefinition.type;
|
|
}
|
|
}
|
|
function getNameOfCompilerOptionValue(value, customTypeMap) {
|
|
return forEachEntry(customTypeMap, (mapValue, key) => {
|
|
if (mapValue === value) {
|
|
return key;
|
|
}
|
|
});
|
|
}
|
|
function serializeCompilerOptions(options, pathOptions) {
|
|
return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
|
|
}
|
|
function serializeWatchOptions(options) {
|
|
return serializeOptionBaseObject(options, getWatchOptionsNameMap());
|
|
}
|
|
function serializeOptionBaseObject(options, { optionsNameMap }, pathOptions) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = pathOptions && createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);
|
|
for (const name in options) {
|
|
if (hasProperty(options, name)) {
|
|
if (optionsNameMap.has(name) && (optionsNameMap.get(name).category === Diagnostics.Command_line_Options || optionsNameMap.get(name).category === Diagnostics.Output_Formatting)) {
|
|
continue;
|
|
}
|
|
const value = options[name];
|
|
const optionDefinition = optionsNameMap.get(name.toLowerCase());
|
|
if (optionDefinition) {
|
|
const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
|
|
if (!customTypeMap) {
|
|
if (pathOptions && optionDefinition.isFilePath) {
|
|
result.set(name, getRelativePathFromFile(pathOptions.configFilePath, getNormalizedAbsolutePath(value, getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName));
|
|
} else {
|
|
result.set(name, value);
|
|
}
|
|
} else {
|
|
if (optionDefinition.type === "list") {
|
|
result.set(name, value.map((element) => getNameOfCompilerOptionValue(element, customTypeMap)));
|
|
} else {
|
|
result.set(name, getNameOfCompilerOptionValue(value, customTypeMap));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getCompilerOptionsDiffValue(options, newLine) {
|
|
const compilerOptionsMap = getSerializedCompilerOption(options);
|
|
return getOverwrittenDefaultOptions();
|
|
function makePadding(paddingLength) {
|
|
return Array(paddingLength + 1).join(" ");
|
|
}
|
|
function getOverwrittenDefaultOptions() {
|
|
const result = [];
|
|
const tab = makePadding(2);
|
|
commandOptionsWithoutBuild.forEach((cmd) => {
|
|
if (!compilerOptionsMap.has(cmd.name)) {
|
|
return;
|
|
}
|
|
const newValue = compilerOptionsMap.get(cmd.name);
|
|
const defaultValue = getDefaultValueForOption(cmd);
|
|
if (newValue !== defaultValue) {
|
|
result.push(`${tab}${cmd.name}: ${newValue}`);
|
|
} else if (hasProperty(defaultInitCompilerOptions, cmd.name)) {
|
|
result.push(`${tab}${cmd.name}: ${defaultValue}`);
|
|
}
|
|
});
|
|
return result.join(newLine) + newLine;
|
|
}
|
|
}
|
|
function getSerializedCompilerOption(options) {
|
|
const compilerOptions = extend(options, defaultInitCompilerOptions);
|
|
return serializeCompilerOptions(compilerOptions);
|
|
}
|
|
function generateTSConfig(options, fileNames, newLine) {
|
|
const compilerOptionsMap = getSerializedCompilerOption(options);
|
|
return writeConfigurations();
|
|
function makePadding(paddingLength) {
|
|
return Array(paddingLength + 1).join(" ");
|
|
}
|
|
function isAllowedOptionForOutput({ category, name, isCommandLineOnly }) {
|
|
const categoriesToSkip = [Diagnostics.Command_line_Options, Diagnostics.Editor_Support, Diagnostics.Compiler_Diagnostics, Diagnostics.Backwards_Compatibility, Diagnostics.Watch_and_Build_Modes, Diagnostics.Output_Formatting];
|
|
return !isCommandLineOnly && category !== void 0 && (!categoriesToSkip.includes(category) || compilerOptionsMap.has(name));
|
|
}
|
|
function writeConfigurations() {
|
|
const categorizedOptions = /* @__PURE__ */ new Map();
|
|
categorizedOptions.set(Diagnostics.Projects, []);
|
|
categorizedOptions.set(Diagnostics.Language_and_Environment, []);
|
|
categorizedOptions.set(Diagnostics.Modules, []);
|
|
categorizedOptions.set(Diagnostics.JavaScript_Support, []);
|
|
categorizedOptions.set(Diagnostics.Emit, []);
|
|
categorizedOptions.set(Diagnostics.Interop_Constraints, []);
|
|
categorizedOptions.set(Diagnostics.Type_Checking, []);
|
|
categorizedOptions.set(Diagnostics.Completeness, []);
|
|
for (const option of optionDeclarations) {
|
|
if (isAllowedOptionForOutput(option)) {
|
|
let listForCategory = categorizedOptions.get(option.category);
|
|
if (!listForCategory)
|
|
categorizedOptions.set(option.category, listForCategory = []);
|
|
listForCategory.push(option);
|
|
}
|
|
}
|
|
let marginLength = 0;
|
|
let seenKnownKeys = 0;
|
|
const entries = [];
|
|
categorizedOptions.forEach((options2, category) => {
|
|
if (entries.length !== 0) {
|
|
entries.push({ value: "" });
|
|
}
|
|
entries.push({ value: `/* ${getLocaleSpecificMessage(category)} */` });
|
|
for (const option of options2) {
|
|
let optionName;
|
|
if (compilerOptionsMap.has(option.name)) {
|
|
optionName = `"${option.name}": ${JSON.stringify(compilerOptionsMap.get(option.name))}${(seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ","}`;
|
|
} else {
|
|
optionName = `// "${option.name}": ${JSON.stringify(getDefaultValueForOption(option))},`;
|
|
}
|
|
entries.push({
|
|
value: optionName,
|
|
description: `/* ${option.description && getLocaleSpecificMessage(option.description) || option.name} */`
|
|
});
|
|
marginLength = Math.max(optionName.length, marginLength);
|
|
}
|
|
});
|
|
const tab = makePadding(2);
|
|
const result = [];
|
|
result.push(`{`);
|
|
result.push(`${tab}"compilerOptions": {`);
|
|
result.push(`${tab}${tab}/* ${getLocaleSpecificMessage(Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file)} */`);
|
|
result.push("");
|
|
for (const entry of entries) {
|
|
const { value, description = "" } = entry;
|
|
result.push(value && `${tab}${tab}${value}${description && makePadding(marginLength - value.length + 2) + description}`);
|
|
}
|
|
if (fileNames.length) {
|
|
result.push(`${tab}},`);
|
|
result.push(`${tab}"files": [`);
|
|
for (let i = 0; i < fileNames.length; i++) {
|
|
result.push(`${tab}${tab}${JSON.stringify(fileNames[i])}${i === fileNames.length - 1 ? "" : ","}`);
|
|
}
|
|
result.push(`${tab}]`);
|
|
} else {
|
|
result.push(`${tab}}`);
|
|
}
|
|
result.push(`}`);
|
|
return result.join(newLine) + newLine;
|
|
}
|
|
}
|
|
function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) {
|
|
const result = {};
|
|
const optionsNameMap = getOptionsNameMap().optionsNameMap;
|
|
for (const name in options) {
|
|
if (hasProperty(options, name)) {
|
|
result[name] = convertToOptionValueWithAbsolutePaths(
|
|
optionsNameMap.get(name.toLowerCase()),
|
|
options[name],
|
|
toAbsolutePath
|
|
);
|
|
}
|
|
}
|
|
if (result.configFilePath) {
|
|
result.configFilePath = toAbsolutePath(result.configFilePath);
|
|
}
|
|
return result;
|
|
}
|
|
function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) {
|
|
if (option && !isNullOrUndefined(value)) {
|
|
if (option.type === "list") {
|
|
const values = value;
|
|
if (option.element.isFilePath && values.length) {
|
|
return values.map(toAbsolutePath);
|
|
}
|
|
} else if (option.isFilePath) {
|
|
return toAbsolutePath(value);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Parse, "parseJsonSourceFileConfigFileContent", { path: sourceFile.fileName });
|
|
const result = parseJsonConfigFileContentWorker(void 0, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function setConfigFileInOptions(options, configFile) {
|
|
if (configFile) {
|
|
Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile });
|
|
}
|
|
}
|
|
function isNullOrUndefined(x) {
|
|
return x === void 0 || x === null;
|
|
}
|
|
function directoryOfCombinedPath(fileName, basePath) {
|
|
return getDirectoryPath(getNormalizedAbsolutePath(fileName, basePath));
|
|
}
|
|
var defaultIncludeSpec = "**/*";
|
|
function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions = {}, existingWatchOptions, configFileName, resolutionStack = [], extraFileExtensions = [], extendedConfigCache) {
|
|
Debug.assert(json === void 0 && sourceFile !== void 0 || json !== void 0 && sourceFile === void 0);
|
|
const errors = [];
|
|
const parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache);
|
|
const { raw } = parsedConfig;
|
|
const options = extend(existingOptions, parsedConfig.options || {});
|
|
const watchOptions = existingWatchOptions && parsedConfig.watchOptions ? extend(existingWatchOptions, parsedConfig.watchOptions) : parsedConfig.watchOptions || existingWatchOptions;
|
|
options.configFilePath = configFileName && normalizeSlashes(configFileName);
|
|
const configFileSpecs = getConfigFileSpecs();
|
|
if (sourceFile)
|
|
sourceFile.configFileSpecs = configFileSpecs;
|
|
setConfigFileInOptions(options, sourceFile);
|
|
const basePathForFileNames = normalizePath(configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath);
|
|
return {
|
|
options,
|
|
watchOptions,
|
|
fileNames: getFileNames(basePathForFileNames),
|
|
projectReferences: getProjectReferences(basePathForFileNames),
|
|
typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(),
|
|
raw,
|
|
errors,
|
|
wildcardDirectories: getWildcardDirectories(configFileSpecs, basePathForFileNames, host.useCaseSensitiveFileNames),
|
|
compileOnSave: !!raw.compileOnSave
|
|
};
|
|
function getConfigFileSpecs() {
|
|
const referencesOfRaw = getPropFromRaw("references", (element) => typeof element === "object", "object");
|
|
const filesSpecs = toPropValue(getSpecsFromRaw("files"));
|
|
if (filesSpecs) {
|
|
const hasZeroOrNoReferences = referencesOfRaw === "no-prop" || isArray(referencesOfRaw) && referencesOfRaw.length === 0;
|
|
const hasExtends = hasProperty(raw, "extends");
|
|
if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) {
|
|
if (sourceFile) {
|
|
const fileName = configFileName || "tsconfig.json";
|
|
const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
|
|
const nodeValue = firstDefined(getTsConfigPropArray(sourceFile, "files"), (property) => property.initializer);
|
|
const error = nodeValue ? createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName) : createCompilerDiagnostic(diagnosticMessage, fileName);
|
|
errors.push(error);
|
|
} else {
|
|
createCompilerDiagnosticOnlyIfJson(Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
|
|
}
|
|
}
|
|
}
|
|
let includeSpecs = toPropValue(getSpecsFromRaw("include"));
|
|
const excludeOfRaw = getSpecsFromRaw("exclude");
|
|
let isDefaultIncludeSpec = false;
|
|
let excludeSpecs = toPropValue(excludeOfRaw);
|
|
if (excludeOfRaw === "no-prop" && raw.compilerOptions) {
|
|
const outDir = raw.compilerOptions.outDir;
|
|
const declarationDir = raw.compilerOptions.declarationDir;
|
|
if (outDir || declarationDir) {
|
|
excludeSpecs = [outDir, declarationDir].filter((d) => !!d);
|
|
}
|
|
}
|
|
if (filesSpecs === void 0 && includeSpecs === void 0) {
|
|
includeSpecs = [defaultIncludeSpec];
|
|
isDefaultIncludeSpec = true;
|
|
}
|
|
let validatedIncludeSpecs, validatedExcludeSpecs;
|
|
if (includeSpecs) {
|
|
validatedIncludeSpecs = validateSpecs(includeSpecs, errors, true, sourceFile, "include");
|
|
}
|
|
if (excludeSpecs) {
|
|
validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, false, sourceFile, "exclude");
|
|
}
|
|
return {
|
|
filesSpecs,
|
|
includeSpecs,
|
|
excludeSpecs,
|
|
validatedFilesSpec: filter(filesSpecs, isString),
|
|
validatedIncludeSpecs,
|
|
validatedExcludeSpecs,
|
|
pathPatterns: void 0,
|
|
isDefaultIncludeSpec
|
|
};
|
|
}
|
|
function getFileNames(basePath2) {
|
|
const fileNames = getFileNamesFromConfigSpecs(configFileSpecs, basePath2, options, host, extraFileExtensions);
|
|
if (shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(raw), resolutionStack)) {
|
|
errors.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
|
|
}
|
|
return fileNames;
|
|
}
|
|
function getProjectReferences(basePath2) {
|
|
let projectReferences;
|
|
const referencesOfRaw = getPropFromRaw("references", (element) => typeof element === "object", "object");
|
|
if (isArray(referencesOfRaw)) {
|
|
for (const ref of referencesOfRaw) {
|
|
if (typeof ref.path !== "string") {
|
|
createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string");
|
|
} else {
|
|
(projectReferences || (projectReferences = [])).push({
|
|
path: getNormalizedAbsolutePath(ref.path, basePath2),
|
|
originalPath: ref.path,
|
|
prepend: ref.prepend,
|
|
circular: ref.circular
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return projectReferences;
|
|
}
|
|
function toPropValue(specResult) {
|
|
return isArray(specResult) ? specResult : void 0;
|
|
}
|
|
function getSpecsFromRaw(prop) {
|
|
return getPropFromRaw(prop, isString, "string");
|
|
}
|
|
function getPropFromRaw(prop, validateElement, elementTypeName) {
|
|
if (hasProperty(raw, prop) && !isNullOrUndefined(raw[prop])) {
|
|
if (isArray(raw[prop])) {
|
|
const result = raw[prop];
|
|
if (!sourceFile && !every(result, validateElement)) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, elementTypeName));
|
|
}
|
|
return result;
|
|
} else {
|
|
createCompilerDiagnosticOnlyIfJson(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(createCompilerDiagnostic(message, arg0, arg1));
|
|
}
|
|
}
|
|
}
|
|
function isErrorNoInputFiles(error) {
|
|
return error.code === Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code;
|
|
}
|
|
function getErrorForNoInputFiles({ includeSpecs, excludeSpecs }, configFileName) {
|
|
return createCompilerDiagnostic(
|
|
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);
|
|
}
|
|
function canJsonReportNoInputFiles(raw) {
|
|
return !hasProperty(raw, "files") && !hasProperty(raw, "references");
|
|
}
|
|
function updateErrorForNoInputFiles(fileNames, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) {
|
|
const existingErrors = configParseDiagnostics.length;
|
|
if (shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles)) {
|
|
configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
|
|
} else {
|
|
filterMutate(configParseDiagnostics, (error) => !isErrorNoInputFiles(error));
|
|
}
|
|
return existingErrors !== configParseDiagnostics.length;
|
|
}
|
|
function isSuccessfulParsedTsconfig(value) {
|
|
return !!value.options;
|
|
}
|
|
function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) {
|
|
var _a2;
|
|
basePath = normalizeSlashes(basePath);
|
|
const resolvedPath = getNormalizedAbsolutePath(configFileName || "", basePath);
|
|
if (resolutionStack.indexOf(resolvedPath) >= 0) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, [...resolutionStack, resolvedPath].join(" -> ")));
|
|
return { raw: json || convertToObject(sourceFile, errors) };
|
|
}
|
|
const ownConfig = json ? parseOwnConfigOfJson(json, host, basePath, configFileName, errors) : parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors);
|
|
if ((_a2 = ownConfig.options) == null ? void 0 : _a2.paths) {
|
|
ownConfig.options.pathsBasePath = basePath;
|
|
}
|
|
if (ownConfig.extendedConfigPath) {
|
|
resolutionStack = resolutionStack.concat([resolvedPath]);
|
|
const extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, resolutionStack, errors, extendedConfigCache);
|
|
if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) {
|
|
const baseRaw = extendedConfig.raw;
|
|
const raw = ownConfig.raw;
|
|
let relativeDifference;
|
|
const setPropertyInRawIfNotUndefined = (propertyName) => {
|
|
if (!raw[propertyName] && baseRaw[propertyName]) {
|
|
raw[propertyName] = map(baseRaw[propertyName], (path) => isRootedDiskPath(path) ? path : combinePaths(
|
|
relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(ownConfig.extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
|
|
path
|
|
));
|
|
}
|
|
};
|
|
setPropertyInRawIfNotUndefined("include");
|
|
setPropertyInRawIfNotUndefined("exclude");
|
|
setPropertyInRawIfNotUndefined("files");
|
|
if (raw.compileOnSave === void 0) {
|
|
raw.compileOnSave = baseRaw.compileOnSave;
|
|
}
|
|
ownConfig.options = assign({}, extendedConfig.options, ownConfig.options);
|
|
ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ? assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) : ownConfig.watchOptions || extendedConfig.watchOptions;
|
|
}
|
|
}
|
|
return ownConfig;
|
|
}
|
|
function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
|
|
if (hasProperty(json, "excludes")) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
|
|
}
|
|
const options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
|
|
const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName);
|
|
const watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
|
|
json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
|
|
let extendedConfigPath;
|
|
if (json.extends) {
|
|
if (!isString(json.extends)) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
|
|
} else {
|
|
const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
|
|
extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, createCompilerDiagnostic);
|
|
}
|
|
}
|
|
return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
|
|
}
|
|
function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
|
|
const options = getDefaultCompilerOptions(configFileName);
|
|
let typeAcquisition, typingOptionstypeAcquisition;
|
|
let watchOptions;
|
|
let extendedConfigPath;
|
|
let rootCompilerOptions;
|
|
const optionsIterator = {
|
|
onSetValidOptionKeyValueInParent(parentOption, option, value) {
|
|
let 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:
|
|
Debug.fail("Unknown option");
|
|
}
|
|
currentOption[option.name] = normalizeOptionValue(option, basePath, value);
|
|
},
|
|
onSetValidOptionKeyValueInRoot(key, _keyNode, value, valueNode) {
|
|
switch (key) {
|
|
case "extends":
|
|
const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
|
|
extendedConfigPath = getExtendsConfigPath(
|
|
value,
|
|
host,
|
|
newBase,
|
|
errors,
|
|
(message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0)
|
|
);
|
|
return;
|
|
}
|
|
},
|
|
onSetUnknownOptionKeyValueInRoot(key, keyNode, _value, _valueNode) {
|
|
if (key === "excludes") {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, keyNode, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
|
|
}
|
|
if (find(commandOptionsWithoutBuild, (opt) => opt.name === key)) {
|
|
rootCompilerOptions = append(rootCompilerOptions, keyNode);
|
|
}
|
|
}
|
|
};
|
|
const json = convertConfigFileToObject(sourceFile, errors, true, optionsIterator);
|
|
if (!typeAcquisition) {
|
|
if (typingOptionstypeAcquisition) {
|
|
typeAcquisition = typingOptionstypeAcquisition.enableAutoDiscovery !== void 0 ? {
|
|
enable: typingOptionstypeAcquisition.enableAutoDiscovery,
|
|
include: typingOptionstypeAcquisition.include,
|
|
exclude: typingOptionstypeAcquisition.exclude
|
|
} : typingOptionstypeAcquisition;
|
|
} else {
|
|
typeAcquisition = getDefaultTypeAcquisition(configFileName);
|
|
}
|
|
}
|
|
if (rootCompilerOptions && json && json.compilerOptions === void 0) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, getTextOfPropertyName(rootCompilerOptions[0])));
|
|
}
|
|
return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
|
|
}
|
|
function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
|
|
extendedConfig = normalizeSlashes(extendedConfig);
|
|
if (isRootedDiskPath(extendedConfig) || startsWith(extendedConfig, "./") || startsWith(extendedConfig, "../")) {
|
|
let extendedConfigPath = getNormalizedAbsolutePath(extendedConfig, basePath);
|
|
if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json" /* Json */)) {
|
|
extendedConfigPath = `${extendedConfigPath}.json`;
|
|
if (!host.fileExists(extendedConfigPath)) {
|
|
errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
|
|
return void 0;
|
|
}
|
|
}
|
|
return extendedConfigPath;
|
|
}
|
|
const resolved = nodeModuleNameResolver(extendedConfig, combinePaths(basePath, "tsconfig.json"), { moduleResolution: 2 /* NodeJs */ }, host, void 0, void 0, true);
|
|
if (resolved.resolvedModule) {
|
|
return resolved.resolvedModule.resolvedFileName;
|
|
}
|
|
errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
|
|
return void 0;
|
|
}
|
|
function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache) {
|
|
const path = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
|
|
let value;
|
|
let extendedResult;
|
|
let extendedConfig;
|
|
if (extendedConfigCache && (value = extendedConfigCache.get(path))) {
|
|
({ extendedResult, extendedConfig } = value);
|
|
} else {
|
|
extendedResult = readJsonConfigFile(extendedConfigPath, (path2) => host.readFile(path2));
|
|
if (!extendedResult.parseDiagnostics.length) {
|
|
extendedConfig = parseConfig(
|
|
void 0,
|
|
extendedResult,
|
|
host,
|
|
getDirectoryPath(extendedConfigPath),
|
|
getBaseFileName(extendedConfigPath),
|
|
resolutionStack,
|
|
errors,
|
|
extendedConfigCache
|
|
);
|
|
}
|
|
if (extendedConfigCache) {
|
|
extendedConfigCache.set(path, { extendedResult, extendedConfig });
|
|
}
|
|
}
|
|
if (sourceFile) {
|
|
sourceFile.extendedSourceFiles = [extendedResult.fileName];
|
|
if (extendedResult.extendedSourceFiles) {
|
|
sourceFile.extendedSourceFiles.push(...extendedResult.extendedSourceFiles);
|
|
}
|
|
}
|
|
if (extendedResult.parseDiagnostics.length) {
|
|
errors.push(...extendedResult.parseDiagnostics);
|
|
return void 0;
|
|
}
|
|
return extendedConfig;
|
|
}
|
|
function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) {
|
|
if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) {
|
|
return false;
|
|
}
|
|
const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
|
|
return typeof result === "boolean" && result;
|
|
}
|
|
function getDefaultCompilerOptions(configFileName) {
|
|
const options = configFileName && getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true } : {};
|
|
return options;
|
|
}
|
|
function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
|
|
const options = getDefaultCompilerOptions(configFileName);
|
|
convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, compilerOptionsDidYouMeanDiagnostics, errors);
|
|
if (configFileName) {
|
|
options.configFilePath = normalizeSlashes(configFileName);
|
|
}
|
|
return options;
|
|
}
|
|
function getDefaultTypeAcquisition(configFileName) {
|
|
return { enable: !!configFileName && getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] };
|
|
}
|
|
function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
|
|
const options = getDefaultTypeAcquisition(configFileName);
|
|
const typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions);
|
|
convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors);
|
|
return options;
|
|
}
|
|
function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) {
|
|
return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, void 0, watchOptionsDidYouMeanDiagnostics, errors);
|
|
}
|
|
function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) {
|
|
if (!jsonOptions) {
|
|
return;
|
|
}
|
|
for (const id in jsonOptions) {
|
|
const opt = optionsNameMap.get(id);
|
|
if (opt) {
|
|
(defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
|
|
} else {
|
|
errors.push(createUnknownOptionError(id, diagnostics, createCompilerDiagnostic));
|
|
}
|
|
}
|
|
return defaultOptions;
|
|
}
|
|
function convertJsonOption(opt, value, basePath, errors) {
|
|
if (isCompilerOptionsValue(opt, value)) {
|
|
const optType = opt.type;
|
|
if (optType === "list" && isArray(value)) {
|
|
return convertJsonOptionOfListType(opt, value, basePath, errors);
|
|
} else if (!isString(optType)) {
|
|
return convertJsonOptionOfCustomType(opt, value, errors);
|
|
}
|
|
const validatedValue = validateJsonOptionValue(opt, value, errors);
|
|
return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue);
|
|
} else {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
|
|
}
|
|
}
|
|
function normalizeOptionValue(option, basePath, value) {
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
if (option.type === "list") {
|
|
const listOption = option;
|
|
if (listOption.element.isFilePath || !isString(listOption.element.type)) {
|
|
return filter(map(value, (v) => normalizeOptionValue(listOption.element, basePath, v)), (v) => listOption.listPreserveFalsyValues ? true : !!v);
|
|
}
|
|
return value;
|
|
} else if (!isString(option.type)) {
|
|
return option.type.get(isString(value) ? value.toLowerCase() : value);
|
|
}
|
|
return normalizeNonListOptionValue(option, basePath, value);
|
|
}
|
|
function normalizeNonListOptionValue(option, basePath, value) {
|
|
if (option.isFilePath) {
|
|
value = getNormalizedAbsolutePath(value, basePath);
|
|
if (value === "") {
|
|
value = ".";
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function validateJsonOptionValue(opt, value, errors) {
|
|
var _a2;
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
const d = (_a2 = opt.extraValidation) == null ? void 0 : _a2.call(opt, value);
|
|
if (!d)
|
|
return value;
|
|
errors.push(createCompilerDiagnostic(...d));
|
|
return void 0;
|
|
}
|
|
function convertJsonOptionOfCustomType(opt, value, errors) {
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
const key = value.toLowerCase();
|
|
const val = opt.type.get(key);
|
|
if (val !== void 0) {
|
|
return validateJsonOptionValue(opt, val, errors);
|
|
} else {
|
|
errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
|
|
}
|
|
}
|
|
function convertJsonOptionOfListType(option, values, basePath, errors) {
|
|
return filter(map(values, (v) => convertJsonOption(option.element, v, basePath, errors)), (v) => option.listPreserveFalsyValues ? true : !!v);
|
|
}
|
|
var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
|
|
var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
|
|
function getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions = emptyArray) {
|
|
basePath = normalizePath(basePath);
|
|
const keyMapper = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
|
|
const literalFileMap = /* @__PURE__ */ new Map();
|
|
const wildcardFileMap = /* @__PURE__ */ new Map();
|
|
const wildCardJsonFileMap = /* @__PURE__ */ new Map();
|
|
const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = configFileSpecs;
|
|
const supportedExtensions = getSupportedExtensions(options, extraFileExtensions);
|
|
const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
|
|
if (validatedFilesSpec) {
|
|
for (const fileName of validatedFilesSpec) {
|
|
const file = getNormalizedAbsolutePath(fileName, basePath);
|
|
literalFileMap.set(keyMapper(file), file);
|
|
}
|
|
}
|
|
let jsonOnlyIncludeRegexes;
|
|
if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
|
|
for (const file of host.readDirectory(basePath, flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, void 0)) {
|
|
if (fileExtensionIs(file, ".json" /* Json */)) {
|
|
if (!jsonOnlyIncludeRegexes) {
|
|
const includes = validatedIncludeSpecs.filter((s) => endsWith(s, ".json" /* Json */));
|
|
const includeFilePatterns = map(getRegularExpressionsForWildcards(includes, basePath, "files"), (pattern) => `^${pattern}$`);
|
|
jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, host.useCaseSensitiveFileNames)) : emptyArray;
|
|
}
|
|
const includeIndex = findIndex(jsonOnlyIncludeRegexes, (re) => re.test(file));
|
|
if (includeIndex !== -1) {
|
|
const key2 = keyMapper(file);
|
|
if (!literalFileMap.has(key2) && !wildCardJsonFileMap.has(key2)) {
|
|
wildCardJsonFileMap.set(key2, file);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
|
|
continue;
|
|
}
|
|
removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
|
|
const key = keyMapper(file);
|
|
if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
|
|
wildcardFileMap.set(key, file);
|
|
}
|
|
}
|
|
}
|
|
const literalFiles = arrayFrom(literalFileMap.values());
|
|
const wildcardFiles = arrayFrom(wildcardFileMap.values());
|
|
return literalFiles.concat(wildcardFiles, arrayFrom(wildCardJsonFileMap.values()));
|
|
}
|
|
function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames, currentDirectory) {
|
|
const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = spec;
|
|
if (!length(validatedIncludeSpecs) || !length(validatedExcludeSpecs))
|
|
return false;
|
|
basePath = normalizePath(basePath);
|
|
const keyMapper = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
if (validatedFilesSpec) {
|
|
for (const fileName of validatedFilesSpec) {
|
|
if (keyMapper(getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck)
|
|
return false;
|
|
}
|
|
}
|
|
return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath);
|
|
}
|
|
function invalidDotDotAfterRecursiveWildcard(s) {
|
|
const wildcardIndex = startsWith(s, "**/") ? 0 : s.indexOf("/**/");
|
|
if (wildcardIndex === -1) {
|
|
return false;
|
|
}
|
|
const lastDotIndex = endsWith(s, "/..") ? s.length : s.lastIndexOf("/../");
|
|
return lastDotIndex > wildcardIndex;
|
|
}
|
|
function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory) {
|
|
return matchesExcludeWorker(
|
|
pathToCheck,
|
|
filter(excludeSpecs, (spec) => !invalidDotDotAfterRecursiveWildcard(spec)),
|
|
useCaseSensitiveFileNames,
|
|
currentDirectory
|
|
);
|
|
}
|
|
function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath) {
|
|
const excludePattern = getRegularExpressionForWildcard(excludeSpecs, combinePaths(normalizePath(currentDirectory), basePath), "exclude");
|
|
const excludeRegex = excludePattern && getRegexFromPattern(excludePattern, useCaseSensitiveFileNames);
|
|
if (!excludeRegex)
|
|
return false;
|
|
if (excludeRegex.test(pathToCheck))
|
|
return true;
|
|
return !hasExtension(pathToCheck) && excludeRegex.test(ensureTrailingDirectorySeparator(pathToCheck));
|
|
}
|
|
function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile, specKey) {
|
|
return specs.filter((spec) => {
|
|
if (!isString(spec))
|
|
return false;
|
|
const diag2 = specToDiagnostic(spec, disallowTrailingRecursion);
|
|
if (diag2 !== void 0) {
|
|
errors.push(createDiagnostic(...diag2));
|
|
}
|
|
return diag2 === void 0;
|
|
});
|
|
function createDiagnostic(message, spec) {
|
|
const element = getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
|
|
return element ? createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : createCompilerDiagnostic(message, spec);
|
|
}
|
|
}
|
|
function specToDiagnostic(spec, disallowTrailingRecursion) {
|
|
if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
|
|
return [Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
|
|
} else if (invalidDotDotAfterRecursiveWildcard(spec)) {
|
|
return [Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
|
|
}
|
|
}
|
|
function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, path, useCaseSensitiveFileNames) {
|
|
const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
|
|
const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
|
|
const wildcardDirectories = {};
|
|
if (include !== void 0) {
|
|
const recursiveKeys = [];
|
|
for (const file of include) {
|
|
const spec = normalizePath(combinePaths(path, file));
|
|
if (excludeRegex && excludeRegex.test(spec)) {
|
|
continue;
|
|
}
|
|
const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
|
|
if (match) {
|
|
const { key, flags } = match;
|
|
const existingFlags = wildcardDirectories[key];
|
|
if (existingFlags === void 0 || existingFlags < flags) {
|
|
wildcardDirectories[key] = flags;
|
|
if (flags === 1 /* Recursive */) {
|
|
recursiveKeys.push(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const key in wildcardDirectories) {
|
|
if (hasProperty(wildcardDirectories, key)) {
|
|
for (const recursiveKey of recursiveKeys) {
|
|
if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
|
|
delete wildcardDirectories[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return wildcardDirectories;
|
|
}
|
|
function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) {
|
|
const match = wildcardDirectoryPattern.exec(spec);
|
|
if (match) {
|
|
const questionWildcardIndex = spec.indexOf("?");
|
|
const starWildcardIndex = spec.indexOf("*");
|
|
const lastDirectorySeperatorIndex = spec.lastIndexOf(directorySeparator);
|
|
return {
|
|
key: useCaseSensitiveFileNames ? match[0] : toFileNameLowerCase(match[0]),
|
|
flags: questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex || starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex ? 1 /* Recursive */ : 0 /* None */
|
|
};
|
|
}
|
|
if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
|
|
return {
|
|
key: removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : toFileNameLowerCase(spec)),
|
|
flags: 1 /* Recursive */
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
|
|
const extensionGroup = forEach(extensions, (group2) => fileExtensionIsOneOf(file, group2) ? group2 : void 0);
|
|
if (!extensionGroup) {
|
|
return false;
|
|
}
|
|
for (const ext of extensionGroup) {
|
|
if (fileExtensionIs(file, ext)) {
|
|
return false;
|
|
}
|
|
const higherPriorityPath = keyMapper(changeExtension(file, ext));
|
|
if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
|
|
if (ext === ".d.ts" /* Dts */ && (fileExtensionIs(file, ".js" /* Js */) || fileExtensionIs(file, ".jsx" /* Jsx */))) {
|
|
continue;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
|
|
const extensionGroup = forEach(extensions, (group2) => fileExtensionIsOneOf(file, group2) ? group2 : void 0);
|
|
if (!extensionGroup) {
|
|
return;
|
|
}
|
|
for (let i = extensionGroup.length - 1; i >= 0; i--) {
|
|
const ext = extensionGroup[i];
|
|
if (fileExtensionIs(file, ext)) {
|
|
return;
|
|
}
|
|
const lowerPriorityPath = keyMapper(changeExtension(file, ext));
|
|
wildcardFiles.delete(lowerPriorityPath);
|
|
}
|
|
}
|
|
function getDefaultValueForOption(option) {
|
|
switch (option.type) {
|
|
case "number":
|
|
return 1;
|
|
case "boolean":
|
|
return true;
|
|
case "string":
|
|
const defaultValue = option.defaultValueDescription;
|
|
return option.isFilePath ? `./${defaultValue && typeof defaultValue === "string" ? defaultValue : ""}` : "";
|
|
case "list":
|
|
return [];
|
|
case "object":
|
|
return {};
|
|
default:
|
|
const iterResult = option.type.keys().next();
|
|
if (!iterResult.done)
|
|
return iterResult.value;
|
|
return Debug.fail("Expected 'option.type' to have entries.");
|
|
}
|
|
}
|
|
|
|
// src/compiler/moduleNameResolver.ts
|
|
function trace(host) {
|
|
host.trace(formatMessage.apply(void 0, arguments));
|
|
}
|
|
function isTraceEnabled(compilerOptions, host) {
|
|
return !!compilerOptions.traceResolution && host.trace !== void 0;
|
|
}
|
|
function withPackageId(packageInfo, r) {
|
|
let packageId;
|
|
if (r && packageInfo) {
|
|
const packageJsonContent = packageInfo.contents.packageJsonContent;
|
|
if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {
|
|
packageId = {
|
|
name: packageJsonContent.name,
|
|
subModuleName: r.path.slice(packageInfo.packageDirectory.length + directorySeparator.length),
|
|
version: packageJsonContent.version
|
|
};
|
|
}
|
|
}
|
|
return r && { path: r.path, extension: r.ext, packageId };
|
|
}
|
|
function noPackageId(r) {
|
|
return withPackageId(void 0, r);
|
|
}
|
|
function removeIgnoredPackageId(r) {
|
|
if (r) {
|
|
Debug.assert(r.packageId === void 0);
|
|
return { path: r.path, ext: r.extension };
|
|
}
|
|
}
|
|
function formatExtensions(extensions) {
|
|
const result = [];
|
|
if (extensions & 1 /* TypeScript */)
|
|
result.push("TypeScript");
|
|
if (extensions & 2 /* JavaScript */)
|
|
result.push("JavaScript");
|
|
if (extensions & 4 /* Declaration */)
|
|
result.push("Declaration");
|
|
if (extensions & 8 /* Json */)
|
|
result.push("JSON");
|
|
return result.join(", ");
|
|
}
|
|
function resolvedTypeScriptOnly(resolved) {
|
|
if (!resolved) {
|
|
return void 0;
|
|
}
|
|
Debug.assert(extensionIsTS(resolved.extension));
|
|
return { fileName: resolved.path, packageId: resolved.packageId };
|
|
}
|
|
function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
|
|
if (resultFromCache) {
|
|
resultFromCache.failedLookupLocations.push(...failedLookupLocations);
|
|
resultFromCache.affectingLocations.push(...affectingLocations);
|
|
return resultFromCache;
|
|
}
|
|
return {
|
|
resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? void 0 : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
resolutionDiagnostics: diagnostics
|
|
};
|
|
}
|
|
function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
|
|
if (!hasProperty(jsonContent, fieldName)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_does_not_have_a_0_field, fieldName);
|
|
}
|
|
return;
|
|
}
|
|
const value = jsonContent[fieldName];
|
|
if (typeof value !== typeOfTag || value === null) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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) {
|
|
const fileName = readPackageJsonField(jsonContent, fieldName, "string", state);
|
|
if (fileName === void 0) {
|
|
return;
|
|
}
|
|
if (!fileName) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_had_a_falsy_0_field, fieldName);
|
|
}
|
|
return;
|
|
}
|
|
const path = normalizePath(combinePaths(baseDirectory, fileName));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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) {
|
|
const typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);
|
|
if (typesVersions === void 0)
|
|
return;
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);
|
|
}
|
|
return typesVersions;
|
|
}
|
|
function readPackageJsonTypesVersionPaths(jsonContent, state) {
|
|
const typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);
|
|
if (typesVersions === void 0)
|
|
return;
|
|
if (state.traceEnabled) {
|
|
for (const key in typesVersions) {
|
|
if (hasProperty(typesVersions, key) && !VersionRange.tryParse(key)) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);
|
|
}
|
|
}
|
|
}
|
|
const result = getPackageJsonTypesVersionsPaths(typesVersions);
|
|
if (!result) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, versionMajorMinor);
|
|
}
|
|
return;
|
|
}
|
|
const { version: bestVersionKey, paths: bestVersionPaths } = result;
|
|
if (typeof bestVersionPaths !== "object") {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersions['${bestVersionKey}']`, "object", typeof bestVersionPaths);
|
|
}
|
|
return;
|
|
}
|
|
return result;
|
|
}
|
|
var typeScriptVersion;
|
|
function getPackageJsonTypesVersionsPaths(typesVersions) {
|
|
if (!typeScriptVersion)
|
|
typeScriptVersion = new Version(version);
|
|
for (const key in typesVersions) {
|
|
if (!hasProperty(typesVersions, key))
|
|
continue;
|
|
const keyRange = VersionRange.tryParse(key);
|
|
if (keyRange === void 0) {
|
|
continue;
|
|
}
|
|
if (keyRange.test(typeScriptVersion)) {
|
|
return { version: key, paths: typesVersions[key] };
|
|
}
|
|
}
|
|
}
|
|
function getEffectiveTypeRoots(options, host) {
|
|
if (options.typeRoots) {
|
|
return options.typeRoots;
|
|
}
|
|
let currentDirectory;
|
|
if (options.configFilePath) {
|
|
currentDirectory = getDirectoryPath(options.configFilePath);
|
|
} else if (host.getCurrentDirectory) {
|
|
currentDirectory = host.getCurrentDirectory();
|
|
}
|
|
if (currentDirectory !== void 0) {
|
|
return getDefaultTypeRoots(currentDirectory, host);
|
|
}
|
|
}
|
|
function getDefaultTypeRoots(currentDirectory, host) {
|
|
if (!host.directoryExists) {
|
|
return [combinePaths(currentDirectory, nodeModulesAtTypes)];
|
|
}
|
|
let typeRoots;
|
|
forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => {
|
|
const atTypes = combinePaths(directory, nodeModulesAtTypes);
|
|
if (host.directoryExists(atTypes)) {
|
|
(typeRoots || (typeRoots = [])).push(atTypes);
|
|
}
|
|
return void 0;
|
|
});
|
|
return typeRoots;
|
|
}
|
|
var nodeModulesAtTypes = combinePaths("node_modules", "@types");
|
|
function arePathsEqual(path1, path2, host) {
|
|
const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
|
|
return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 0 /* EqualTo */;
|
|
}
|
|
function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
|
|
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.");
|
|
const traceEnabled = isTraceEnabled(options, host);
|
|
if (redirectedReference) {
|
|
options = redirectedReference.commandLine.options;
|
|
}
|
|
const containingDirectory = containingFile ? getDirectoryPath(containingFile) : void 0;
|
|
const perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : void 0;
|
|
let result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, resolutionMode);
|
|
if (result) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
|
|
if (redirectedReference)
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
trace(host, Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory);
|
|
traceResult(result);
|
|
}
|
|
return result;
|
|
}
|
|
const typeRoots = getEffectiveTypeRoots(options, host);
|
|
if (traceEnabled) {
|
|
if (containingFile === void 0) {
|
|
if (typeRoots === void 0) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
|
|
} else {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
|
|
}
|
|
} else {
|
|
if (typeRoots === void 0) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
|
|
} else {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
|
|
}
|
|
}
|
|
if (redirectedReference) {
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
}
|
|
}
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
let features = getDefaultNodeResolutionFeatures(options);
|
|
if (resolutionMode === 99 /* ESNext */ && (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */)) {
|
|
features |= NodeResolutionFeatures.EsmMode;
|
|
}
|
|
const conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
|
|
const diagnostics = [];
|
|
const moduleResolutionState = {
|
|
compilerOptions: options,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features,
|
|
conditions,
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
let resolved = primaryLookup();
|
|
let primary = true;
|
|
if (!resolved) {
|
|
resolved = secondaryLookup();
|
|
primary = false;
|
|
}
|
|
let resolvedTypeReferenceDirective;
|
|
if (resolved) {
|
|
const { fileName, packageId } = resolved;
|
|
const resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
|
|
const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);
|
|
resolvedTypeReferenceDirective = {
|
|
primary,
|
|
resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,
|
|
originalPath: pathsAreEqual ? void 0 : fileName,
|
|
packageId,
|
|
isExternalLibraryImport: pathContainsNodeModules(fileName)
|
|
};
|
|
}
|
|
result = { resolvedTypeReferenceDirective, failedLookupLocations, affectingLocations, resolutionDiagnostics: diagnostics };
|
|
perFolderCache == null ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
|
|
if (traceEnabled)
|
|
traceResult(result);
|
|
return result;
|
|
function traceResult(result2) {
|
|
var _a2;
|
|
if (!((_a2 = result2.resolvedTypeReferenceDirective) == null ? void 0 : _a2.resolvedFileName)) {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
|
|
} else if (result2.resolvedTypeReferenceDirective.packageId) {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result2.resolvedTypeReferenceDirective.resolvedFileName, packageIdToString(result2.resolvedTypeReferenceDirective.packageId), result2.resolvedTypeReferenceDirective.primary);
|
|
} else {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result2.resolvedTypeReferenceDirective.resolvedFileName, result2.resolvedTypeReferenceDirective.primary);
|
|
}
|
|
}
|
|
function primaryLookup() {
|
|
if (typeRoots && typeRoots.length) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
|
|
}
|
|
return firstDefined(typeRoots, (typeRoot) => {
|
|
const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
|
|
const candidateDirectory = getDirectoryPath(candidate);
|
|
const directoryExists = directoryProbablyExists(candidateDirectory, host);
|
|
if (!directoryExists && traceEnabled) {
|
|
trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
|
|
}
|
|
return resolvedTypeScriptOnly(
|
|
loadNodeModuleFromDirectory(
|
|
4 /* Declaration */,
|
|
candidate,
|
|
!directoryExists,
|
|
moduleResolutionState
|
|
)
|
|
);
|
|
});
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
|
|
}
|
|
}
|
|
}
|
|
function secondaryLookup() {
|
|
const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);
|
|
if (initialLocationForSecondaryLookup !== void 0) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
|
|
}
|
|
let result2;
|
|
if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
|
|
const searchResult = loadModuleFromNearestNodeModulesDirectory(4 /* Declaration */, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, void 0, void 0);
|
|
result2 = searchResult && searchResult.value;
|
|
} else {
|
|
const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
|
|
result2 = nodeLoadModuleByRelativeName(4 /* Declaration */, candidate, false, moduleResolutionState, true);
|
|
}
|
|
return resolvedTypeScriptOnly(result2);
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getDefaultNodeResolutionFeatures(options) {
|
|
return getEmitModuleResolutionKind(options) === 3 /* Node16 */ ? NodeResolutionFeatures.Node16Default : getEmitModuleResolutionKind(options) === 99 /* NodeNext */ ? NodeResolutionFeatures.NodeNextDefault : NodeResolutionFeatures.None;
|
|
}
|
|
function getAutomaticTypeDirectiveNames(options, host) {
|
|
if (options.types) {
|
|
return options.types;
|
|
}
|
|
const result = [];
|
|
if (host.directoryExists && host.getDirectories) {
|
|
const typeRoots = getEffectiveTypeRoots(options, host);
|
|
if (typeRoots) {
|
|
for (const root of typeRoots) {
|
|
if (host.directoryExists(root)) {
|
|
for (const typeDirectivePath of host.getDirectories(root)) {
|
|
const normalized = normalizePath(typeDirectivePath);
|
|
const packageJsonPath = combinePaths(root, normalized, "package.json");
|
|
const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
|
|
if (!isNotNeededPackage) {
|
|
const baseFileName = getBaseFileName(normalized);
|
|
if (baseFileName.charCodeAt(0) !== 46 /* dot */) {
|
|
result.push(baseFileName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function createCacheWithRedirects(options) {
|
|
let ownMap = /* @__PURE__ */ new Map();
|
|
const redirectsMap = /* @__PURE__ */ new Map();
|
|
return {
|
|
getOwnMap,
|
|
redirectsMap,
|
|
getOrCreateMapOfCacheRedirects,
|
|
clear: clear2,
|
|
setOwnOptions,
|
|
setOwnMap
|
|
};
|
|
function getOwnMap() {
|
|
return ownMap;
|
|
}
|
|
function setOwnOptions(newOptions) {
|
|
options = newOptions;
|
|
}
|
|
function setOwnMap(newOwnMap) {
|
|
ownMap = newOwnMap;
|
|
}
|
|
function getOrCreateMapOfCacheRedirects(redirectedReference) {
|
|
if (!redirectedReference) {
|
|
return ownMap;
|
|
}
|
|
const path = redirectedReference.sourceFile.path;
|
|
let redirects = redirectsMap.get(path);
|
|
if (!redirects) {
|
|
redirects = !options || optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? /* @__PURE__ */ new Map() : ownMap;
|
|
redirectsMap.set(path, redirects);
|
|
}
|
|
return redirects;
|
|
}
|
|
function clear2() {
|
|
ownMap.clear();
|
|
redirectsMap.clear();
|
|
}
|
|
}
|
|
function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
|
|
let cache;
|
|
return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, entries, getInternalMap };
|
|
function getPackageJsonInfo2(packageJsonPath) {
|
|
return cache == null ? void 0 : cache.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
|
|
}
|
|
function setPackageJsonInfo(packageJsonPath, info) {
|
|
(cache || (cache = /* @__PURE__ */ new Map())).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
|
|
}
|
|
function clear2() {
|
|
cache = void 0;
|
|
}
|
|
function entries() {
|
|
const iter = cache == null ? void 0 : cache.entries();
|
|
return iter ? arrayFrom(iter) : [];
|
|
}
|
|
function getInternalMap() {
|
|
return cache;
|
|
}
|
|
}
|
|
function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
|
|
const cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
|
|
let 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) {
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size === 0);
|
|
Debug.assert(directoryToModuleNameMap.getOwnMap().size === 0);
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.getOwnMap().size === 0);
|
|
directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.getOwnMap());
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.getOwnMap());
|
|
} else {
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size > 0);
|
|
const ref = {
|
|
sourceFile: options.configFile,
|
|
commandLine: { options }
|
|
};
|
|
directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
|
|
}
|
|
directoryToModuleNameMap.setOwnOptions(options);
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.setOwnOptions(options);
|
|
}
|
|
function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) {
|
|
return {
|
|
getOrCreateCacheForDirectory,
|
|
clear: clear2,
|
|
update
|
|
};
|
|
function clear2() {
|
|
directoryToModuleNameMap.clear();
|
|
}
|
|
function update(options) {
|
|
updateRedirectsMap(options, directoryToModuleNameMap);
|
|
}
|
|
function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
|
|
const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
|
|
return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, () => createModeAwareCache());
|
|
}
|
|
}
|
|
function createModeAwareCache() {
|
|
const underlying = /* @__PURE__ */ new Map();
|
|
const memoizedReverseKeys = /* @__PURE__ */ new Map();
|
|
const cache = {
|
|
get(specifier, mode) {
|
|
return underlying.get(getUnderlyingCacheKey(specifier, mode));
|
|
},
|
|
set(specifier, mode, value) {
|
|
underlying.set(getUnderlyingCacheKey(specifier, mode), value);
|
|
return cache;
|
|
},
|
|
delete(specifier, mode) {
|
|
underlying.delete(getUnderlyingCacheKey(specifier, mode));
|
|
return cache;
|
|
},
|
|
has(specifier, mode) {
|
|
return underlying.has(getUnderlyingCacheKey(specifier, mode));
|
|
},
|
|
forEach(cb) {
|
|
return underlying.forEach((elem, key) => {
|
|
const [specifier, mode] = memoizedReverseKeys.get(key);
|
|
return cb(elem, specifier, mode);
|
|
});
|
|
},
|
|
size() {
|
|
return underlying.size;
|
|
}
|
|
};
|
|
return cache;
|
|
function getUnderlyingCacheKey(specifier, mode) {
|
|
const result = mode === void 0 ? specifier : `${mode}|${specifier}`;
|
|
memoizedReverseKeys.set(result, [specifier, mode]);
|
|
return result;
|
|
}
|
|
}
|
|
function getResolutionName(entry) {
|
|
return !isString(entry) ? isStringLiteralLike(entry) ? entry.text : toFileNameLowerCase(entry.fileName) : entry;
|
|
}
|
|
function getResolutionMode(entry, file) {
|
|
return isStringLiteralLike(entry) ? getModeForUsageLocation(file, entry) : entry.resolutionMode || file.impliedNodeFormat;
|
|
}
|
|
function zipToModeAwareCache(file, keys, values) {
|
|
Debug.assert(keys.length === values.length);
|
|
const map2 = createModeAwareCache();
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
const entry = keys[i];
|
|
map2.set(getResolutionName(entry), getResolutionMode(entry, file), values[i]);
|
|
}
|
|
return map2;
|
|
}
|
|
function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
|
|
const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
|
|
moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
|
|
const packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
|
|
return {
|
|
...packageJsonInfoCache,
|
|
...perDirectoryResolutionCache,
|
|
getOrCreateCacheForModuleName,
|
|
clear: clear2,
|
|
update,
|
|
getPackageJsonInfoCache: () => packageJsonInfoCache,
|
|
clearAllExceptPackageJsonInfoCache
|
|
};
|
|
function clear2() {
|
|
clearAllExceptPackageJsonInfoCache();
|
|
packageJsonInfoCache.clear();
|
|
}
|
|
function clearAllExceptPackageJsonInfoCache() {
|
|
perDirectoryResolutionCache.clear();
|
|
moduleNameToDirectoryMap.clear();
|
|
}
|
|
function update(options2) {
|
|
updateRedirectsMap(options2, directoryToModuleNameMap, moduleNameToDirectoryMap);
|
|
}
|
|
function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
|
|
Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));
|
|
return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === void 0 ? nonRelativeModuleName : `${mode}|${nonRelativeModuleName}`, createPerModuleNameCache);
|
|
}
|
|
function createPerModuleNameCache() {
|
|
const directoryPathMap = /* @__PURE__ */ new Map();
|
|
return { get, set };
|
|
function get(directory) {
|
|
return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
|
|
}
|
|
function set(directory, result) {
|
|
const path = toPath(directory, currentDirectory, getCanonicalFileName);
|
|
if (directoryPathMap.has(path)) {
|
|
return;
|
|
}
|
|
directoryPathMap.set(path, result);
|
|
const resolvedFileName = result.resolvedModule && (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
|
|
const commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
|
|
let current = path;
|
|
while (current !== commonPrefix) {
|
|
const parent = getDirectoryPath(current);
|
|
if (parent === current || directoryPathMap.has(parent)) {
|
|
break;
|
|
}
|
|
directoryPathMap.set(parent, result);
|
|
current = parent;
|
|
}
|
|
}
|
|
function getCommonPrefix(directory, resolution) {
|
|
const resolutionDirectory = toPath(getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
|
|
let i = 0;
|
|
const 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] === directorySeparator)) {
|
|
return directory;
|
|
}
|
|
const rootLength = getRootLength(directory);
|
|
if (i < rootLength) {
|
|
return void 0;
|
|
}
|
|
const sep = directory.lastIndexOf(directorySeparator, i - 1);
|
|
if (sep === -1) {
|
|
return void 0;
|
|
}
|
|
return directory.substr(0, Math.max(sep, rootLength));
|
|
}
|
|
}
|
|
}
|
|
function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) {
|
|
const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
|
|
packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
|
|
return {
|
|
...packageJsonInfoCache,
|
|
...perDirectoryResolutionCache,
|
|
clear: clear2,
|
|
clearAllExceptPackageJsonInfoCache
|
|
};
|
|
function clear2() {
|
|
clearAllExceptPackageJsonInfoCache();
|
|
packageJsonInfoCache.clear();
|
|
}
|
|
function clearAllExceptPackageJsonInfoCache() {
|
|
perDirectoryResolutionCache.clear();
|
|
}
|
|
}
|
|
function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
|
|
if (!perFolderCache)
|
|
return void 0;
|
|
return perFolderCache.get(moduleName, mode);
|
|
}
|
|
function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
if (redirectedReference) {
|
|
compilerOptions = redirectedReference.commandLine.options;
|
|
}
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
|
|
if (redirectedReference) {
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
}
|
|
}
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
|
|
let result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
|
|
if (result) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
|
|
}
|
|
} else {
|
|
let moduleResolution = compilerOptions.moduleResolution;
|
|
if (moduleResolution === void 0) {
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 1 /* CommonJS */:
|
|
moduleResolution = 2 /* NodeJs */;
|
|
break;
|
|
case 100 /* Node16 */:
|
|
moduleResolution = 3 /* Node16 */;
|
|
break;
|
|
case 199 /* NodeNext */:
|
|
moduleResolution = 99 /* NodeNext */;
|
|
break;
|
|
default:
|
|
moduleResolution = 1 /* Classic */;
|
|
break;
|
|
}
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);
|
|
}
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);
|
|
}
|
|
}
|
|
perfLogger.logStartResolveModule(moduleName);
|
|
switch (moduleResolution) {
|
|
case 3 /* Node16 */:
|
|
result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
|
|
break;
|
|
case 99 /* NodeNext */:
|
|
result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
|
|
break;
|
|
case 2 /* NodeJs */:
|
|
result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
|
|
break;
|
|
case 1 /* Classic */:
|
|
result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
|
|
break;
|
|
default:
|
|
return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`);
|
|
}
|
|
if (result && result.resolvedModule)
|
|
perfLogger.logInfoEvent(`Module "${moduleName}" resolved to "${result.resolvedModule.resolvedFileName}"`);
|
|
perfLogger.logStopResolveModule(result && result.resolvedModule ? "" + result.resolvedModule.resolvedFileName : "null");
|
|
if (perFolderCache) {
|
|
perFolderCache.set(moduleName, resolutionMode, result);
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
|
|
}
|
|
}
|
|
}
|
|
if (traceEnabled) {
|
|
if (result.resolvedModule) {
|
|
if (result.resolvedModule.packageId) {
|
|
trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, packageIdToString(result.resolvedModule.packageId));
|
|
} else {
|
|
trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
|
|
}
|
|
} else {
|
|
trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) {
|
|
const resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state);
|
|
if (resolved)
|
|
return resolved.value;
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state);
|
|
} else {
|
|
return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state);
|
|
}
|
|
}
|
|
function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) {
|
|
var _a2;
|
|
const { baseUrl, paths, configFile } = state.compilerOptions;
|
|
if (paths && !pathIsRelative(moduleName)) {
|
|
if (state.traceEnabled) {
|
|
if (baseUrl) {
|
|
trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
|
|
}
|
|
trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
|
|
}
|
|
const baseDirectory = getPathsBasePath(state.compilerOptions, state.host);
|
|
const pathPatterns = (configFile == null ? void 0 : configFile.configFileSpecs) ? (_a2 = configFile.configFileSpecs).pathPatterns || (_a2.pathPatterns = tryParsePatterns(paths)) : void 0;
|
|
return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, false, state);
|
|
}
|
|
}
|
|
function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) {
|
|
if (!state.compilerOptions.rootDirs) {
|
|
return void 0;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
|
|
}
|
|
const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
|
|
let matchedRootDir;
|
|
let matchedNormalizedPrefix;
|
|
for (const rootDir of state.compilerOptions.rootDirs) {
|
|
let normalizedRoot = normalizePath(rootDir);
|
|
if (!endsWith(normalizedRoot, directorySeparator)) {
|
|
normalizedRoot += directorySeparator;
|
|
}
|
|
const isLongestMatchingPrefix = startsWith(candidate, normalizedRoot) && (matchedNormalizedPrefix === void 0 || matchedNormalizedPrefix.length < normalizedRoot.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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, Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
|
|
}
|
|
const suffix = candidate.substr(matchedNormalizedPrefix.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
|
|
}
|
|
const resolvedFileName = loader(extensions, candidate, !directoryProbablyExists(containingDirectory, state.host), state);
|
|
if (resolvedFileName) {
|
|
return resolvedFileName;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Trying_other_entries_in_rootDirs);
|
|
}
|
|
for (const rootDir of state.compilerOptions.rootDirs) {
|
|
if (rootDir === matchedRootDir) {
|
|
continue;
|
|
}
|
|
const candidate2 = combinePaths(normalizePath(rootDir), suffix);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate2);
|
|
}
|
|
const baseDirectory = getDirectoryPath(candidate2);
|
|
const resolvedFileName2 = loader(extensions, candidate2, !directoryProbablyExists(baseDirectory, state.host), state);
|
|
if (resolvedFileName2) {
|
|
return resolvedFileName2;
|
|
}
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Module_resolution_using_rootDirs_has_failed);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) {
|
|
const { baseUrl } = state.compilerOptions;
|
|
if (!baseUrl) {
|
|
return void 0;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
|
|
}
|
|
const candidate = normalizePath(combinePaths(baseUrl, moduleName));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate);
|
|
}
|
|
return loader(extensions, candidate, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
|
|
}
|
|
function resolveJSModule(moduleName, initialDir, host) {
|
|
const { resolvedModule, failedLookupLocations } = tryResolveJSModuleWorker(moduleName, initialDir, host);
|
|
if (!resolvedModule) {
|
|
throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations.join(", ")}`);
|
|
}
|
|
return resolvedModule.resolvedFileName;
|
|
}
|
|
var NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => {
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Imports"] = 2] = "Imports";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["SelfName"] = 4] = "SelfName";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Exports"] = 8] = "Exports";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["AllFeatures"] = 30] = "AllFeatures";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Node16Default"] = 30] = "Node16Default";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["NodeNextDefault"] = 30 /* AllFeatures */] = "NodeNextDefault";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["EsmMode"] = 32] = "EsmMode";
|
|
return NodeResolutionFeatures2;
|
|
})(NodeResolutionFeatures || {});
|
|
function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
return nodeNextModuleNameResolverWorker(
|
|
30 /* Node16Default */,
|
|
moduleName,
|
|
containingFile,
|
|
compilerOptions,
|
|
host,
|
|
cache,
|
|
redirectedReference,
|
|
resolutionMode
|
|
);
|
|
}
|
|
function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
return nodeNextModuleNameResolverWorker(
|
|
30 /* NodeNextDefault */,
|
|
moduleName,
|
|
containingFile,
|
|
compilerOptions,
|
|
host,
|
|
cache,
|
|
redirectedReference,
|
|
resolutionMode
|
|
);
|
|
}
|
|
function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const esmMode = resolutionMode === 99 /* ESNext */ ? 32 /* EsmMode */ : 0;
|
|
let extensions = compilerOptions.noDtsResolution ? 3 /* ImplementationFiles */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
|
|
if (compilerOptions.resolveJsonModule) {
|
|
extensions |= 8 /* Json */;
|
|
}
|
|
return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, false, redirectedReference);
|
|
}
|
|
function tryResolveJSModuleWorker(moduleName, initialDir, host) {
|
|
return nodeModuleNameResolverWorker(
|
|
0 /* None */,
|
|
moduleName,
|
|
initialDir,
|
|
{ moduleResolution: 2 /* NodeJs */, allowJs: true },
|
|
host,
|
|
void 0,
|
|
2 /* JavaScript */,
|
|
false,
|
|
void 0
|
|
);
|
|
}
|
|
function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, isConfigLookup) {
|
|
let extensions;
|
|
if (isConfigLookup) {
|
|
extensions = 8 /* Json */;
|
|
} else if (compilerOptions.noDtsResolution) {
|
|
extensions = 3 /* ImplementationFiles */;
|
|
if (compilerOptions.resolveJsonModule)
|
|
extensions |= 8 /* Json */;
|
|
} else {
|
|
extensions = compilerOptions.resolveJsonModule ? 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */ | 8 /* Json */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
|
|
}
|
|
return nodeModuleNameResolverWorker(0 /* None */, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference);
|
|
}
|
|
function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, isConfigLookup, redirectedReference) {
|
|
var _a2, _b;
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const conditions = features & 32 /* EsmMode */ ? ["node", "import", "types"] : ["node", "require", "types"];
|
|
if (compilerOptions.noDtsResolution) {
|
|
conditions.pop();
|
|
}
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features,
|
|
conditions,
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup
|
|
};
|
|
if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) <= 99 /* NodeNext */) {
|
|
trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & 32 /* EsmMode */ ? "ESM" : "CJS", conditions.map((c) => `'${c}'`).join(", "));
|
|
}
|
|
let result;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */) {
|
|
const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
|
|
const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
|
|
result = priorityExtensions && tryResolve(priorityExtensions) || secondaryExtensions && tryResolve(secondaryExtensions) || void 0;
|
|
} else {
|
|
result = tryResolve(extensions);
|
|
}
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
(_a2 = result == null ? void 0 : result.value) == null ? void 0 : _a2.resolved,
|
|
(_b = result == null ? void 0 : result.value) == null ? void 0 : _b.isExternalLibraryImport,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
function tryResolve(extensions2) {
|
|
const loader = (extensions3, candidate, onlyRecordFailures, state2) => nodeLoadModuleByRelativeName(extensions3, candidate, onlyRecordFailures, state2, true);
|
|
const resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions2, moduleName, containingDirectory, loader, state);
|
|
if (resolved) {
|
|
return toSearchResult({ resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
|
|
}
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
let resolved2;
|
|
if (features & 2 /* Imports */ && startsWith(moduleName, "#")) {
|
|
resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2 && features & 4 /* SelfName */) {
|
|
resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
|
|
}
|
|
resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2)
|
|
return void 0;
|
|
let resolvedValue = resolved2.value;
|
|
if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
|
|
const path = realPath(resolvedValue.path, host, traceEnabled);
|
|
const pathsAreEqual = arePathsEqual(path, resolvedValue.path, host);
|
|
const originalPath = pathsAreEqual ? void 0 : resolvedValue.path;
|
|
resolvedValue = { ...resolvedValue, path: pathsAreEqual ? resolvedValue.path : path, originalPath };
|
|
}
|
|
return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
|
|
} else {
|
|
const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
|
|
const resolved2 = nodeLoadModuleByRelativeName(extensions2, candidate, false, state, true);
|
|
return resolved2 && toSearchResult({ resolved: resolved2, isExternalLibraryImport: contains(parts, "node_modules") });
|
|
}
|
|
}
|
|
}
|
|
function normalizePathForCJSResolution(containingDirectory, moduleName) {
|
|
const combined = combinePaths(containingDirectory, moduleName);
|
|
const parts = getPathComponents(combined);
|
|
const lastPart = lastOrUndefined(parts);
|
|
const path = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
|
|
return { path, parts };
|
|
}
|
|
function realPath(path, host, traceEnabled) {
|
|
if (!host.realpath) {
|
|
return path;
|
|
}
|
|
const real = normalizePath(host.realpath(path));
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path, real);
|
|
}
|
|
Debug.assert(host.fileExists(real), `${path} linked to nonexistent file ${real}`);
|
|
return real;
|
|
}
|
|
function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1, candidate, formatExtensions(extensions));
|
|
}
|
|
if (!hasTrailingDirectorySeparator(candidate)) {
|
|
if (!onlyRecordFailures) {
|
|
const parentOfCandidate = getDirectoryPath(candidate);
|
|
if (!directoryProbablyExists(parentOfCandidate, state.host)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
|
|
}
|
|
onlyRecordFailures = true;
|
|
}
|
|
}
|
|
const resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state);
|
|
if (resolvedFromFile) {
|
|
const packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile.path) : void 0;
|
|
const packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, false, state) : void 0;
|
|
return withPackageId(packageInfo, resolvedFromFile);
|
|
}
|
|
}
|
|
if (!onlyRecordFailures) {
|
|
const candidateExists = directoryProbablyExists(candidate, state.host);
|
|
if (!candidateExists) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
|
|
}
|
|
onlyRecordFailures = true;
|
|
}
|
|
}
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
|
|
}
|
|
return void 0;
|
|
}
|
|
var nodeModulesPathPart = "/node_modules/";
|
|
function pathContainsNodeModules(path) {
|
|
return stringContains(path, nodeModulesPathPart);
|
|
}
|
|
function parseNodeModuleFromPath(resolved) {
|
|
const path = normalizePath(resolved);
|
|
const idx = path.lastIndexOf(nodeModulesPathPart);
|
|
if (idx === -1) {
|
|
return void 0;
|
|
}
|
|
const indexAfterNodeModules = idx + nodeModulesPathPart.length;
|
|
let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules);
|
|
if (path.charCodeAt(indexAfterNodeModules) === 64 /* at */) {
|
|
indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName);
|
|
}
|
|
return path.slice(0, indexAfterPackageName);
|
|
}
|
|
function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) {
|
|
const nextSeparatorIndex = path.indexOf(directorySeparator, prevSeparatorIndex + 1);
|
|
return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex;
|
|
}
|
|
function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
|
|
return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
|
|
}
|
|
function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
|
|
const resolvedByReplacingExtension = loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
|
|
if (resolvedByReplacingExtension) {
|
|
return resolvedByReplacingExtension;
|
|
}
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, "", onlyRecordFailures, state);
|
|
if (resolvedByAddingExtension) {
|
|
return resolvedByAddingExtension;
|
|
}
|
|
}
|
|
}
|
|
function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state) {
|
|
if (hasJSFileExtension(candidate) || extensions & 8 /* Json */ && fileExtensionIs(candidate, ".json" /* Json */)) {
|
|
const extensionless = removeFileExtension(candidate);
|
|
const extension = candidate.substring(extensionless.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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 & 1 /* TypeScript */ && fileExtensionIsOneOf(candidate, supportedTSImplementationExtensions) || extensions & 4 /* Declaration */ && fileExtensionIsOneOf(candidate, supportedDeclarationExtensions)) {
|
|
const result = tryFile(candidate, onlyRecordFailures, state);
|
|
return result !== void 0 ? { path: candidate, ext: tryExtractTSExtension(candidate) } : void 0;
|
|
}
|
|
return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
|
|
}
|
|
function tryAddingExtensions(candidate, extensions, originalExtension, onlyRecordFailures, state) {
|
|
if (!onlyRecordFailures) {
|
|
const directory = getDirectoryPath(candidate);
|
|
if (directory) {
|
|
onlyRecordFailures = !directoryProbablyExists(directory, state.host);
|
|
}
|
|
}
|
|
switch (originalExtension) {
|
|
case ".mjs" /* Mjs */:
|
|
case ".mts" /* Mts */:
|
|
case ".d.mts" /* Dmts */:
|
|
return extensions & 1 /* TypeScript */ && tryExtension(".mts" /* Mts */) || extensions & 4 /* Declaration */ && tryExtension(".d.mts" /* Dmts */) || extensions & 2 /* JavaScript */ && tryExtension(".mjs" /* Mjs */) || void 0;
|
|
case ".cjs" /* Cjs */:
|
|
case ".cts" /* Cts */:
|
|
case ".d.cts" /* Dcts */:
|
|
return extensions & 1 /* TypeScript */ && tryExtension(".cts" /* Cts */) || extensions & 4 /* Declaration */ && tryExtension(".d.cts" /* Dcts */) || extensions & 2 /* JavaScript */ && tryExtension(".cjs" /* Cjs */) || void 0;
|
|
case ".json" /* Json */:
|
|
const originalCandidate = candidate;
|
|
if (extensions & 4 /* Declaration */) {
|
|
candidate += ".json" /* Json */;
|
|
const result = tryExtension(".d.ts" /* Dts */);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (extensions & 8 /* Json */) {
|
|
candidate = originalCandidate;
|
|
const result = tryExtension(".json" /* Json */);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return void 0;
|
|
default:
|
|
return extensions & 1 /* TypeScript */ && (tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */)) || extensions & 4 /* Declaration */ && tryExtension(".d.ts" /* Dts */) || extensions & 2 /* JavaScript */ && (tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */)) || state.isConfigLookup && tryExtension(".json" /* Json */) || void 0;
|
|
}
|
|
function tryExtension(ext) {
|
|
const path = tryFile(candidate + ext, onlyRecordFailures, state);
|
|
return path === void 0 ? void 0 : { path, ext };
|
|
}
|
|
}
|
|
function tryFile(fileName, onlyRecordFailures, state) {
|
|
var _a2, _b;
|
|
if (!((_a2 = state.compilerOptions.moduleSuffixes) == null ? void 0 : _a2.length)) {
|
|
return tryFileLookup(fileName, onlyRecordFailures, state);
|
|
}
|
|
const ext = (_b = tryGetExtensionFromPath2(fileName)) != null ? _b : "";
|
|
const fileNameNoExtension = ext ? removeExtension(fileName, ext) : fileName;
|
|
return forEach(state.compilerOptions.moduleSuffixes, (suffix) => tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state));
|
|
}
|
|
function tryFileLookup(fileName, onlyRecordFailures, state) {
|
|
if (!onlyRecordFailures) {
|
|
if (state.host.fileExists(fileName)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
|
|
}
|
|
return fileName;
|
|
} else {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
|
|
}
|
|
}
|
|
}
|
|
state.failedLookupLocations.push(fileName);
|
|
return void 0;
|
|
}
|
|
function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
|
|
const packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : void 0;
|
|
const packageJsonContent = packageInfo && packageInfo.contents.packageJsonContent;
|
|
const versionPaths = packageInfo && packageInfo.contents.versionPaths;
|
|
return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
|
|
}
|
|
function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options) {
|
|
return {
|
|
host,
|
|
compilerOptions: options,
|
|
traceEnabled: isTraceEnabled(options, host),
|
|
failedLookupLocations: noopPush,
|
|
affectingLocations: noopPush,
|
|
packageJsonInfoCache,
|
|
features: 0 /* None */,
|
|
conditions: emptyArray,
|
|
requestContainingDirectory: void 0,
|
|
reportDiagnostic: noop,
|
|
isConfigLookup: false
|
|
};
|
|
}
|
|
function getPackageScopeForPath(fileName, state) {
|
|
const parts = getPathComponents(fileName);
|
|
parts.pop();
|
|
while (parts.length > 0) {
|
|
const pkg = getPackageJsonInfo(getPathFromPathComponents(parts), false, state);
|
|
if (pkg) {
|
|
return pkg;
|
|
}
|
|
parts.pop();
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
|
|
var _a2, _b, _c;
|
|
const { host, traceEnabled } = state;
|
|
const packageJsonPath = combinePaths(packageDirectory, "package.json");
|
|
if (onlyRecordFailures) {
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
return void 0;
|
|
}
|
|
const existing = (_a2 = state.packageJsonInfoCache) == null ? void 0 : _a2.getPackageJsonInfo(packageJsonPath);
|
|
if (existing !== void 0) {
|
|
if (typeof existing !== "boolean") {
|
|
if (traceEnabled)
|
|
trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
|
|
state.affectingLocations.push(packageJsonPath);
|
|
return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
|
|
} else {
|
|
if (existing && traceEnabled)
|
|
trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
return void 0;
|
|
}
|
|
}
|
|
const directoryExists = directoryProbablyExists(packageDirectory, host);
|
|
if (directoryExists && host.fileExists(packageJsonPath)) {
|
|
const packageJsonContent = readJson(packageJsonPath, host);
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
|
|
}
|
|
const versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
|
|
const result = { packageDirectory, contents: { packageJsonContent, versionPaths, resolvedEntrypoints: void 0 } };
|
|
(_b = state.packageJsonInfoCache) == null ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
|
|
state.affectingLocations.push(packageJsonPath);
|
|
return result;
|
|
} else {
|
|
if (directoryExists && traceEnabled) {
|
|
trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
|
|
}
|
|
(_c = state.packageJsonInfoCache) == null ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists);
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
}
|
|
}
|
|
function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
|
|
let packageFile;
|
|
if (jsonContent) {
|
|
if (state.isConfigLookup) {
|
|
packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
|
|
} else {
|
|
packageFile = extensions & 4 /* Declaration */ && readPackageJsonTypesFields(jsonContent, candidate, state) || extensions & (3 /* ImplementationFiles */ | 4 /* Declaration */) && readPackageJsonMainField(jsonContent, candidate, state) || void 0;
|
|
}
|
|
}
|
|
const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => {
|
|
const fromFile = tryFile(candidate2, onlyRecordFailures2, state2);
|
|
if (fromFile) {
|
|
const resolved = resolvedIfExtensionMatches(extensions2, fromFile);
|
|
if (resolved) {
|
|
return noPackageId(resolved);
|
|
}
|
|
if (state2.traceEnabled) {
|
|
trace(state2.host, Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile);
|
|
}
|
|
}
|
|
const expandedExtensions = extensions2 === 4 /* Declaration */ ? 1 /* TypeScript */ | 4 /* Declaration */ : extensions2;
|
|
const features = state2.features;
|
|
if ((jsonContent == null ? void 0 : jsonContent.type) !== "module") {
|
|
state2.features &= ~32 /* EsmMode */;
|
|
}
|
|
const result = nodeLoadModuleByRelativeName(expandedExtensions, candidate2, onlyRecordFailures2, state2, false);
|
|
state2.features = features;
|
|
return result;
|
|
};
|
|
const onlyRecordFailuresForPackageFile = packageFile ? !directoryProbablyExists(getDirectoryPath(packageFile), state.host) : void 0;
|
|
const onlyRecordFailuresForIndex = onlyRecordFailures || !directoryProbablyExists(candidate, state.host);
|
|
const indexPath = combinePaths(candidate, state.isConfigLookup ? "tsconfig" : "index");
|
|
if (versionPaths && (!packageFile || containsPath(candidate, packageFile))) {
|
|
const moduleName = getRelativePathFromDirectory(candidate, packageFile || indexPath, false);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName);
|
|
}
|
|
const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, void 0, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
|
|
if (result) {
|
|
return removeIgnoredPackageId(result.value);
|
|
}
|
|
}
|
|
const packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state));
|
|
if (packageFileResult)
|
|
return packageFileResult;
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
|
|
}
|
|
}
|
|
function resolvedIfExtensionMatches(extensions, path) {
|
|
const ext = tryGetExtensionFromPath2(path);
|
|
return ext !== void 0 && extensionIsOk(extensions, ext) ? { path, ext } : void 0;
|
|
}
|
|
function extensionIsOk(extensions, extension) {
|
|
return extensions & 2 /* JavaScript */ && (extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */ || extension === ".mjs" /* Mjs */ || extension === ".cjs" /* Cjs */) || extensions & 1 /* TypeScript */ && (extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */) || extensions & 4 /* Declaration */ && (extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */) || extensions & 8 /* Json */ && extension === ".json" /* Json */ || false;
|
|
}
|
|
function parsePackageName(moduleName) {
|
|
let idx = moduleName.indexOf(directorySeparator);
|
|
if (moduleName[0] === "@") {
|
|
idx = moduleName.indexOf(directorySeparator, idx + 1);
|
|
}
|
|
return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
|
|
}
|
|
function allKeysStartWithDot(obj) {
|
|
return every(getOwnKeys(obj), (k) => startsWith(k, "."));
|
|
}
|
|
function noKeyStartsWithDot(obj) {
|
|
return !some(getOwnKeys(obj), (k) => startsWith(k, "."));
|
|
}
|
|
function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
var _a2, _b;
|
|
const directoryPath = getNormalizedAbsolutePath(combinePaths(directory, "dummy"), (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
const scope = getPackageScopeForPath(directoryPath, state);
|
|
if (!scope || !scope.contents.packageJsonContent.exports) {
|
|
return void 0;
|
|
}
|
|
if (typeof scope.contents.packageJsonContent.name !== "string") {
|
|
return void 0;
|
|
}
|
|
const parts = getPathComponents(moduleName);
|
|
const nameParts = getPathComponents(scope.contents.packageJsonContent.name);
|
|
if (!every(nameParts, (p, i) => parts[i] === p)) {
|
|
return void 0;
|
|
}
|
|
const trailingParts = parts.slice(nameParts.length);
|
|
return loadModuleFromExports(scope, extensions, !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`, state, cache, redirectedReference);
|
|
}
|
|
function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
|
|
if (!scope.contents.packageJsonContent.exports) {
|
|
return void 0;
|
|
}
|
|
if (subpath === ".") {
|
|
let mainExport;
|
|
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 (hasProperty(scope.contents.packageJsonContent.exports, ".")) {
|
|
mainExport = scope.contents.packageJsonContent.exports["."];
|
|
}
|
|
if (mainExport) {
|
|
const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, subpath, scope, false);
|
|
return loadModuleFromTargetImportOrExport(mainExport, "", false, ".");
|
|
}
|
|
} else if (allKeysStartWithDot(scope.contents.packageJsonContent.exports)) {
|
|
if (typeof scope.contents.packageJsonContent.exports !== "object") {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, subpath, scope.contents.packageJsonContent.exports, scope, false);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
function loadModuleFromImports(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
var _a2, _b;
|
|
if (moduleName === "#" || startsWith(moduleName, "#/")) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Invalid_import_specifier_0_has_no_possible_resolutions, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const directoryPath = getNormalizedAbsolutePath(combinePaths(directory, "dummy"), (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
const scope = getPackageScopeForPath(directoryPath, state);
|
|
if (!scope) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, directoryPath);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (!scope.contents.packageJsonContent.imports) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_no_imports_defined, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, scope.contents.packageJsonContent.imports, scope, true);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1, moduleName, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
function comparePatternKeys(a, b) {
|
|
const aPatternIndex = a.indexOf("*");
|
|
const bPatternIndex = b.indexOf("*");
|
|
const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
|
|
const 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;
|
|
}
|
|
function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
|
|
const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
|
|
if (!endsWith(moduleName, directorySeparator) && moduleName.indexOf("*") === -1 && hasProperty(lookupTable, moduleName)) {
|
|
const target = lookupTable[moduleName];
|
|
return loadModuleFromTargetImportOrExport(target, "", false, moduleName);
|
|
}
|
|
const expandingKeys = sort(filter(getOwnKeys(lookupTable), (k) => k.indexOf("*") !== -1 || endsWith(k, "/")), comparePatternKeys);
|
|
for (const potentialTarget of expandingKeys) {
|
|
if (state.features & 16 /* ExportsPatternTrailers */ && matchesPatternWithTrailer(potentialTarget, moduleName)) {
|
|
const target = lookupTable[potentialTarget];
|
|
const starPos = potentialTarget.indexOf("*");
|
|
const subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
|
|
return loadModuleFromTargetImportOrExport(target, subpath, true, potentialTarget);
|
|
} else if (endsWith(potentialTarget, "*") && startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
|
|
const target = lookupTable[potentialTarget];
|
|
const subpath = moduleName.substring(potentialTarget.length - 1);
|
|
return loadModuleFromTargetImportOrExport(target, subpath, true, potentialTarget);
|
|
} else if (startsWith(moduleName, potentialTarget)) {
|
|
const target = lookupTable[potentialTarget];
|
|
const subpath = moduleName.substring(potentialTarget.length);
|
|
return loadModuleFromTargetImportOrExport(target, subpath, false, potentialTarget);
|
|
}
|
|
}
|
|
function matchesPatternWithTrailer(target, name) {
|
|
if (endsWith(target, "*"))
|
|
return false;
|
|
const starPos = target.indexOf("*");
|
|
if (starPos === -1)
|
|
return false;
|
|
return startsWith(name, target.substring(0, starPos)) && endsWith(name, target.substring(starPos + 1));
|
|
}
|
|
}
|
|
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 && !endsWith(target, "/")) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (!startsWith(target, "./")) {
|
|
if (isImports && !startsWith(target, "../") && !startsWith(target, "/") && !isRootedDiskPath(target)) {
|
|
const combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
|
|
traceIfEnabled(state, Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup);
|
|
traceIfEnabled(state, Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/");
|
|
const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, false, redirectedReference);
|
|
return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const parts = pathIsRelative(target) ? getPathComponents(target).slice(1) : getPathComponents(target);
|
|
const partsAfterFirst = parts.slice(1);
|
|
if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const resolvedTarget = combinePaths(scope.packageDirectory, target);
|
|
const subpathParts = getPathComponents(subpath);
|
|
if (subpathParts.indexOf("..") >= 0 || subpathParts.indexOf(".") >= 0 || subpathParts.indexOf("node_modules") >= 0) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(
|
|
state.host,
|
|
Diagnostics.Using_0_subpath_1_with_target_2,
|
|
isImports ? "imports" : "exports",
|
|
key,
|
|
pattern ? target.replace(/\*/g, subpath) : target + subpath
|
|
);
|
|
}
|
|
const finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
|
|
const inputLink = tryLoadInputFileForPath(finalPath, subpath, combinePaths(scope.packageDirectory, "package.json"), isImports);
|
|
if (inputLink)
|
|
return inputLink;
|
|
return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, false, state)));
|
|
} else if (typeof target === "object" && target !== null) {
|
|
if (!Array.isArray(target)) {
|
|
for (const condition of getOwnKeys(target)) {
|
|
if (condition === "default" || state.conditions.indexOf(condition) >= 0 || isApplicableVersionedTypesKey(state.conditions, condition)) {
|
|
traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
|
|
const subTarget = target[condition];
|
|
const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
} else {
|
|
traceIfEnabled(state, Diagnostics.Saw_non_matching_condition_0, condition);
|
|
}
|
|
}
|
|
return void 0;
|
|
} else {
|
|
if (!length(target)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
for (const elem of target) {
|
|
const result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
} else if (target === null) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_explicitly_maps_specifier_1_to_null, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
function toAbsolutePath(path) {
|
|
var _a2, _b;
|
|
if (path === void 0)
|
|
return path;
|
|
return getNormalizedAbsolutePath(path, (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
}
|
|
function combineDirectoryPath(root, dir) {
|
|
return ensureTrailingDirectorySeparator(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, isImports2) {
|
|
var _a2, _b, _c, _d;
|
|
if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) {
|
|
const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames });
|
|
const commonSourceDirGuesses = [];
|
|
if (state.compilerOptions.rootDir || state.compilerOptions.composite && state.compilerOptions.configFilePath) {
|
|
const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], ((_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2)) || "", getCanonicalFileName));
|
|
commonSourceDirGuesses.push(commonDir);
|
|
} else if (state.requestContainingDirectory) {
|
|
const requestingFile = toAbsolutePath(combinePaths(state.requestContainingDirectory, "index.ts"));
|
|
const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [requestingFile, toAbsolutePath(packagePath)], ((_d = (_c = state.host).getCurrentDirectory) == null ? void 0 : _d.call(_c)) || "", getCanonicalFileName));
|
|
commonSourceDirGuesses.push(commonDir);
|
|
let fragment = ensureTrailingDirectorySeparator(commonDir);
|
|
while (fragment && fragment.length > 1) {
|
|
const parts = getPathComponents(fragment);
|
|
parts.pop();
|
|
const commonDir2 = getPathFromPathComponents(parts);
|
|
commonSourceDirGuesses.unshift(commonDir2);
|
|
fragment = ensureTrailingDirectorySeparator(commonDir2);
|
|
}
|
|
}
|
|
if (commonSourceDirGuesses.length > 1) {
|
|
state.reportDiagnostic(createCompilerDiagnostic(
|
|
isImports2 ? 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 : 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,
|
|
packagePath
|
|
));
|
|
}
|
|
for (const commonSourceDirGuess of commonSourceDirGuesses) {
|
|
const candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
|
|
for (const candidateDir of candidateDirectories) {
|
|
if (containsPath(candidateDir, finalPath, !useCaseSensitiveFileNames())) {
|
|
const pathFragment = finalPath.slice(candidateDir.length + 1);
|
|
const possibleInputBase = combinePaths(commonSourceDirGuess, pathFragment);
|
|
const jsAndDtsExtensions = [".mjs" /* Mjs */, ".cjs" /* Cjs */, ".js" /* Js */, ".json" /* Json */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".d.ts" /* Dts */];
|
|
for (const ext of jsAndDtsExtensions) {
|
|
if (fileExtensionIs(possibleInputBase, ext)) {
|
|
const inputExts = getPossibleOriginalInputExtensionForExtension(possibleInputBase);
|
|
for (const possibleExt of inputExts) {
|
|
if (!extensionIsOk(extensions, possibleExt))
|
|
continue;
|
|
const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
|
|
if (state.host.fileExists(possibleInputWithInputExtension)) {
|
|
return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, false, state)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
|
|
var _a3, _b2;
|
|
const currentDir = state.compilerOptions.configFile ? ((_b2 = (_a3 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a3)) || "" : commonSourceDirGuess;
|
|
const 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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isApplicableVersionedTypesKey(conditions, key) {
|
|
if (conditions.indexOf("types") === -1)
|
|
return false;
|
|
if (!startsWith(key, "types@"))
|
|
return false;
|
|
const range = VersionRange.tryParse(key.substring("types@".length));
|
|
if (!range)
|
|
return false;
|
|
return range.test(version);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) {
|
|
return loadModuleFromNearestNodeModulesDirectoryWorker(4 /* Declaration */, moduleName, directory, state, true, void 0, void 0);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
|
|
const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? void 0 : state.features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */, redirectedReference);
|
|
const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
|
|
const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
|
|
if (priorityExtensions) {
|
|
const result = lookup(priorityExtensions);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (secondaryExtensions && !typesScopeOnly) {
|
|
return lookup(secondaryExtensions);
|
|
}
|
|
function lookup(extensions2) {
|
|
return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
|
|
if (getBaseFileName(ancestorDirectory) !== "node_modules") {
|
|
const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
|
|
if (resolutionFromCache) {
|
|
return resolutionFromCache;
|
|
}
|
|
return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
|
|
const nodeModulesFolder = combinePaths(directory, "node_modules");
|
|
const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
|
|
if (!nodeModulesFolderExists && state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
|
|
}
|
|
if (!typesScopeOnly) {
|
|
const packageResult = loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
|
|
if (packageResult) {
|
|
return packageResult;
|
|
}
|
|
}
|
|
if (extensions & 4 /* Declaration */) {
|
|
const nodeModulesAtTypes2 = combinePaths(nodeModulesFolder, "@types");
|
|
let nodeModulesAtTypesExists = nodeModulesFolderExists;
|
|
if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes2, state.host)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes2);
|
|
}
|
|
nodeModulesAtTypesExists = false;
|
|
}
|
|
return loadModuleFromSpecificNodeModulesDirectory(4 /* Declaration */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference);
|
|
}
|
|
}
|
|
function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
|
|
var _a2;
|
|
const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName));
|
|
let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
|
|
if (!(state.features & 8 /* Exports */)) {
|
|
if (packageInfo) {
|
|
const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
|
|
if (fromFile) {
|
|
return noPackageId(fromFile);
|
|
}
|
|
const fromDirectory = loadNodeModuleFromDirectoryWorker(
|
|
extensions,
|
|
candidate,
|
|
!nodeModulesDirectoryExists,
|
|
state,
|
|
packageInfo.contents.packageJsonContent,
|
|
packageInfo.contents.versionPaths
|
|
);
|
|
return withPackageId(packageInfo, fromDirectory);
|
|
}
|
|
}
|
|
const loader = (extensions2, candidate2, onlyRecordFailures, state2) => {
|
|
let pathAndExtension = loadModuleFromFile(extensions2, candidate2, onlyRecordFailures, state2) || loadNodeModuleFromDirectoryWorker(
|
|
extensions2,
|
|
candidate2,
|
|
onlyRecordFailures,
|
|
state2,
|
|
packageInfo && packageInfo.contents.packageJsonContent,
|
|
packageInfo && packageInfo.contents.versionPaths
|
|
);
|
|
if (!pathAndExtension && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32 /* EsmMode */) {
|
|
pathAndExtension = loadModuleFromFile(extensions2, combinePaths(candidate2, "index.js"), onlyRecordFailures, state2);
|
|
}
|
|
return withPackageId(packageInfo, pathAndExtension);
|
|
};
|
|
const { packageName, rest } = parsePackageName(moduleName);
|
|
const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
|
|
if (rest !== "") {
|
|
packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
|
|
}
|
|
if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & 8 /* Exports */) {
|
|
return (_a2 = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache, redirectedReference)) == null ? void 0 : _a2.value;
|
|
}
|
|
if (rest !== "" && packageInfo && packageInfo.contents.versionPaths) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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, version, rest);
|
|
}
|
|
const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
|
|
const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.contents.versionPaths.paths, void 0, 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 = tryParsePatterns(paths));
|
|
const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);
|
|
if (matchedPattern) {
|
|
const matchedStar = isString(matchedPattern) ? void 0 : matchedText(matchedPattern, moduleName);
|
|
const matchedPatternText = isString(matchedPattern) ? matchedPattern : patternText(matchedPattern);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
|
|
}
|
|
const resolved = forEach(paths[matchedPatternText], (subst) => {
|
|
const path = matchedStar ? subst.replace("*", matchedStar) : subst;
|
|
const candidate = normalizePath(combinePaths(baseDirectory, path));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
|
|
}
|
|
const extension = tryGetExtensionFromPath2(subst);
|
|
if (extension !== void 0) {
|
|
const path2 = tryFile(candidate, onlyRecordFailures, state);
|
|
if (path2 !== void 0) {
|
|
return noPackageId({ path: path2, ext: extension });
|
|
}
|
|
}
|
|
return loader(extensions, candidate, onlyRecordFailures || !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
|
|
});
|
|
return { value: resolved };
|
|
}
|
|
}
|
|
var mangledScopedPackageSeparator = "__";
|
|
function mangleScopedPackageNameWithTrace(packageName, state) {
|
|
const mangled = mangleScopedPackageName(packageName);
|
|
if (state.traceEnabled && mangled !== packageName) {
|
|
trace(state.host, Diagnostics.Scoped_package_detected_looking_in_0, mangled);
|
|
}
|
|
return mangled;
|
|
}
|
|
function getTypesPackageName(packageName) {
|
|
return `@types/${mangleScopedPackageName(packageName)}`;
|
|
}
|
|
function mangleScopedPackageName(packageName) {
|
|
if (startsWith(packageName, "@")) {
|
|
const replaceSlash = packageName.replace(directorySeparator, mangledScopedPackageSeparator);
|
|
if (replaceSlash !== packageName) {
|
|
return replaceSlash.slice(1);
|
|
}
|
|
}
|
|
return packageName;
|
|
}
|
|
function getPackageNameFromTypesPackageName(mangledName) {
|
|
const withoutAtTypePrefix = removePrefix(mangledName, "@types/");
|
|
if (withoutAtTypePrefix !== mangledName) {
|
|
return unmangleScopedPackageName(withoutAtTypePrefix);
|
|
}
|
|
return mangledName;
|
|
}
|
|
function unmangleScopedPackageName(typesPackageName) {
|
|
return stringContains(typesPackageName, mangledScopedPackageSeparator) ? "@" + typesPackageName.replace(mangledScopedPackageSeparator, directorySeparator) : typesPackageName;
|
|
}
|
|
function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
|
|
const result = cache && cache.get(containingDirectory);
|
|
if (result) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, 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) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features: 0 /* None */,
|
|
conditions: [],
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
const resolved = tryResolve(1 /* TypeScript */ | 4 /* Declaration */) || tryResolve(2 /* JavaScript */ | (compilerOptions.resolveJsonModule ? 8 /* Json */ : 0));
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
resolved && resolved.value,
|
|
false,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
function tryResolve(extensions) {
|
|
const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
|
|
if (resolvedUsingSettings) {
|
|
return { value: resolvedUsingSettings };
|
|
}
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, void 0, redirectedReference);
|
|
const resolved2 = forEachAncestorDirectory(containingDirectory, (directory) => {
|
|
const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, directory, state);
|
|
if (resolutionFromCache) {
|
|
return resolutionFromCache;
|
|
}
|
|
const searchName = normalizePath(combinePaths(directory, moduleName));
|
|
return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, false, state));
|
|
});
|
|
if (resolved2) {
|
|
return resolved2;
|
|
}
|
|
if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
|
|
return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
|
|
}
|
|
} else {
|
|
const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
|
|
return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, false, state));
|
|
}
|
|
}
|
|
}
|
|
function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
|
|
}
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache,
|
|
features: 0 /* None */,
|
|
conditions: [],
|
|
requestContainingDirectory: void 0,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
const resolved = loadModuleFromImmediateNodeModulesDirectory(4 /* Declaration */, moduleName, globalCache, state, false, void 0, void 0);
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
resolved,
|
|
true,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
}
|
|
function toSearchResult(value) {
|
|
return value !== void 0 ? { value } : void 0;
|
|
}
|
|
function traceIfEnabled(state, diagnostic, ...args) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, diagnostic, ...args);
|
|
}
|
|
}
|
|
|
|
// src/compiler/binder.ts
|
|
function getModuleInstanceState(node, visited) {
|
|
if (node.body && !node.body.parent) {
|
|
setParent(node.body, node);
|
|
setParentRecursive(node.body, false);
|
|
}
|
|
return node.body ? getModuleInstanceStateCached(node.body, visited) : 1 /* Instantiated */;
|
|
}
|
|
function getModuleInstanceStateCached(node, visited = /* @__PURE__ */ new Map()) {
|
|
const nodeId = getNodeId(node);
|
|
if (visited.has(nodeId)) {
|
|
return visited.get(nodeId) || 0 /* NonInstantiated */;
|
|
}
|
|
visited.set(nodeId, void 0);
|
|
const result = getModuleInstanceStateWorker(node, visited);
|
|
visited.set(nodeId, result);
|
|
return result;
|
|
}
|
|
function getModuleInstanceStateWorker(node, visited) {
|
|
switch (node.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return 0 /* NonInstantiated */;
|
|
case 263 /* EnumDeclaration */:
|
|
if (isEnumConst(node)) {
|
|
return 2 /* ConstEnumOnly */;
|
|
}
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (!hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return 0 /* NonInstantiated */;
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
const exportDeclaration = node;
|
|
if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 276 /* NamedExports */) {
|
|
let state = 0 /* NonInstantiated */;
|
|
for (const specifier of exportDeclaration.exportClause.elements) {
|
|
const specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);
|
|
if (specifierState > state) {
|
|
state = specifierState;
|
|
}
|
|
if (state === 1 /* Instantiated */) {
|
|
return state;
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
break;
|
|
case 265 /* ModuleBlock */: {
|
|
let state = 0 /* NonInstantiated */;
|
|
forEachChild(node, (n) => {
|
|
const childState = getModuleInstanceStateCached(n, visited);
|
|
switch (childState) {
|
|
case 0 /* NonInstantiated */:
|
|
return;
|
|
case 2 /* ConstEnumOnly */:
|
|
state = 2 /* ConstEnumOnly */;
|
|
return;
|
|
case 1 /* Instantiated */:
|
|
state = 1 /* Instantiated */;
|
|
return true;
|
|
default:
|
|
Debug.assertNever(childState);
|
|
}
|
|
});
|
|
return state;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
return getModuleInstanceState(node, visited);
|
|
case 79 /* Identifier */:
|
|
if (node.isInJSDocNamespace) {
|
|
return 0 /* NonInstantiated */;
|
|
}
|
|
}
|
|
return 1 /* Instantiated */;
|
|
}
|
|
function getModuleInstanceStateForAliasTarget(specifier, visited) {
|
|
const name = specifier.propertyName || specifier.name;
|
|
let p = specifier.parent;
|
|
while (p) {
|
|
if (isBlock(p) || isModuleBlock(p) || isSourceFile(p)) {
|
|
const statements = p.statements;
|
|
let found;
|
|
for (const statement of statements) {
|
|
if (nodeHasName(statement, name)) {
|
|
if (!statement.parent) {
|
|
setParent(statement, p);
|
|
setParentRecursive(statement, false);
|
|
}
|
|
const state = getModuleInstanceStateCached(statement, visited);
|
|
if (found === void 0 || state > found) {
|
|
found = state;
|
|
}
|
|
if (found === 1 /* Instantiated */) {
|
|
return found;
|
|
}
|
|
}
|
|
}
|
|
if (found !== void 0) {
|
|
return found;
|
|
}
|
|
}
|
|
p = p.parent;
|
|
}
|
|
return 1 /* Instantiated */;
|
|
}
|
|
function initFlowNode(node) {
|
|
Debug.attachFlowNodeDebugInfo(node);
|
|
return node;
|
|
}
|
|
var binder = createBinder();
|
|
function bindSourceFile(file, options) {
|
|
mark("beforeBind");
|
|
perfLogger.logStartBindFile("" + file.fileName);
|
|
binder(file, options);
|
|
perfLogger.logStopBindFile();
|
|
mark("afterBind");
|
|
measure("Bind", "beforeBind", "afterBind");
|
|
}
|
|
function createBinder() {
|
|
let file;
|
|
let options;
|
|
let languageVersion;
|
|
let parent;
|
|
let container;
|
|
let thisParentContainer;
|
|
let blockScopeContainer;
|
|
let lastContainer;
|
|
let delayedTypeAliases;
|
|
let seenThisKeyword;
|
|
let currentFlow;
|
|
let currentBreakTarget;
|
|
let currentContinueTarget;
|
|
let currentReturnTarget;
|
|
let currentTrueTarget;
|
|
let currentFalseTarget;
|
|
let currentExceptionTarget;
|
|
let preSwitchCaseFlow;
|
|
let activeLabelList;
|
|
let hasExplicitReturn;
|
|
let emitFlags;
|
|
let inStrictMode;
|
|
let inAssignmentPattern = false;
|
|
let symbolCount = 0;
|
|
let Symbol12;
|
|
let classifiableNames;
|
|
const unreachableFlow = { flags: 1 /* Unreachable */ };
|
|
const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
|
|
const bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
|
|
function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
|
|
return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
|
|
}
|
|
function bindSourceFile2(f, opts) {
|
|
var _a2, _b;
|
|
file = f;
|
|
options = opts;
|
|
languageVersion = getEmitScriptTarget(options);
|
|
inStrictMode = bindInStrictMode(file, opts);
|
|
classifiableNames = /* @__PURE__ */ new Set();
|
|
symbolCount = 0;
|
|
Symbol12 = objectAllocator.getSymbolConstructor();
|
|
Debug.attachFlowNodeDebugInfo(unreachableFlow);
|
|
Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
|
|
if (!file.locals) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Bind, "bindSourceFile", { path: file.path }, true);
|
|
bind(file);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
file.symbolCount = symbolCount;
|
|
file.classifiableNames = classifiableNames;
|
|
delayedBindJSDocTypedefTag();
|
|
}
|
|
file = void 0;
|
|
options = void 0;
|
|
languageVersion = void 0;
|
|
parent = void 0;
|
|
container = void 0;
|
|
thisParentContainer = void 0;
|
|
blockScopeContainer = void 0;
|
|
lastContainer = void 0;
|
|
delayedTypeAliases = void 0;
|
|
seenThisKeyword = false;
|
|
currentFlow = void 0;
|
|
currentBreakTarget = void 0;
|
|
currentContinueTarget = void 0;
|
|
currentReturnTarget = void 0;
|
|
currentTrueTarget = void 0;
|
|
currentFalseTarget = void 0;
|
|
currentExceptionTarget = void 0;
|
|
activeLabelList = void 0;
|
|
hasExplicitReturn = false;
|
|
inAssignmentPattern = false;
|
|
emitFlags = 0 /* None */;
|
|
}
|
|
return bindSourceFile2;
|
|
function bindInStrictMode(file2, opts) {
|
|
if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
|
|
return true;
|
|
} else {
|
|
return !!file2.externalModuleIndicator;
|
|
}
|
|
}
|
|
function createSymbol(flags, name) {
|
|
symbolCount++;
|
|
return new Symbol12(flags, name);
|
|
}
|
|
function addDeclarationToSymbol(symbol, node, symbolFlags) {
|
|
symbol.flags |= symbolFlags;
|
|
node.symbol = symbol;
|
|
symbol.declarations = appendIfUnique(symbol.declarations, node);
|
|
if (symbolFlags & (32 /* Class */ | 384 /* Enum */ | 1536 /* Module */ | 3 /* Variable */) && !symbol.exports) {
|
|
symbol.exports = createSymbolTable();
|
|
}
|
|
if (symbolFlags & (32 /* Class */ | 64 /* Interface */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && !symbol.members) {
|
|
symbol.members = createSymbolTable();
|
|
}
|
|
if (symbol.constEnumOnlyModule && symbol.flags & (16 /* Function */ | 32 /* Class */ | 256 /* RegularEnum */)) {
|
|
symbol.constEnumOnlyModule = false;
|
|
}
|
|
if (symbolFlags & 111551 /* Value */) {
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
}
|
|
function getDeclarationName(node) {
|
|
if (node.kind === 274 /* ExportAssignment */) {
|
|
return node.isExportEquals ? "export=" /* ExportEquals */ : "default" /* Default */;
|
|
}
|
|
const name = getNameOfDeclaration(node);
|
|
if (name) {
|
|
if (isAmbientModule(node)) {
|
|
const moduleName = getTextOfIdentifierOrLiteral(name);
|
|
return isGlobalScopeAugmentation(node) ? "__global" : `"${moduleName}"`;
|
|
}
|
|
if (name.kind === 164 /* ComputedPropertyName */) {
|
|
const nameExpression = name.expression;
|
|
if (isStringOrNumericLiteralLike(nameExpression)) {
|
|
return escapeLeadingUnderscores(nameExpression.text);
|
|
}
|
|
if (isSignedNumericLiteral(nameExpression)) {
|
|
return tokenToString(nameExpression.operator) + nameExpression.operand.text;
|
|
} else {
|
|
Debug.fail("Only computed properties with literal names have declaration names");
|
|
}
|
|
}
|
|
if (isPrivateIdentifier(name)) {
|
|
const containingClass = getContainingClass(node);
|
|
if (!containingClass) {
|
|
return void 0;
|
|
}
|
|
const containingClassSymbol = containingClass.symbol;
|
|
return getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);
|
|
}
|
|
return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return "__constructor" /* Constructor */;
|
|
case 181 /* FunctionType */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
return "__call" /* Call */;
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
return "__new" /* New */;
|
|
case 178 /* IndexSignature */:
|
|
return "__index" /* Index */;
|
|
case 275 /* ExportDeclaration */:
|
|
return "__export" /* ExportStar */;
|
|
case 308 /* SourceFile */:
|
|
return "export=" /* ExportEquals */;
|
|
case 223 /* BinaryExpression */:
|
|
if (getAssignmentDeclarationKind(node) === 2 /* ModuleExports */) {
|
|
return "export=" /* ExportEquals */;
|
|
}
|
|
Debug.fail("Unknown binary declaration kind");
|
|
break;
|
|
case 320 /* JSDocFunctionType */:
|
|
return isJSDocConstructSignature(node) ? "__new" /* New */ : "__call" /* Call */;
|
|
case 166 /* Parameter */:
|
|
Debug.assert(node.parent.kind === 320 /* JSDocFunctionType */, "Impossible parameter parent kind", () => `parent is: ${Debug.formatSyntaxKind(node.parent.kind)}, expected JSDocFunctionType`);
|
|
const functionType = node.parent;
|
|
const index = functionType.parameters.indexOf(node);
|
|
return "arg" + index;
|
|
}
|
|
}
|
|
function getDisplayName(node) {
|
|
return isNamedDeclaration(node) ? declarationNameToString(node.name) : unescapeLeadingUnderscores(Debug.checkDefined(getDeclarationName(node)));
|
|
}
|
|
function declareSymbol(symbolTable, parent2, node, includes, excludes, isReplaceableByMethod, isComputedName) {
|
|
Debug.assert(isComputedName || !hasDynamicName(node));
|
|
const isDefaultExport = hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node) && node.name.escapedText === "default";
|
|
const name = isComputedName ? "__computed" /* Computed */ : isDefaultExport && parent2 ? "default" /* Default */ : getDeclarationName(node);
|
|
let symbol;
|
|
if (name === void 0) {
|
|
symbol = createSymbol(0 /* None */, "__missing" /* Missing */);
|
|
} else {
|
|
symbol = symbolTable.get(name);
|
|
if (includes & 2885600 /* Classifiable */) {
|
|
classifiableNames.add(name);
|
|
}
|
|
if (!symbol) {
|
|
symbolTable.set(name, symbol = createSymbol(0 /* None */, name));
|
|
if (isReplaceableByMethod)
|
|
symbol.isReplaceableByMethod = true;
|
|
} else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) {
|
|
return symbol;
|
|
} else if (symbol.flags & excludes) {
|
|
if (symbol.isReplaceableByMethod) {
|
|
symbolTable.set(name, symbol = createSymbol(0 /* None */, name));
|
|
} else if (!(includes & 3 /* Variable */ && symbol.flags & 67108864 /* Assignment */)) {
|
|
if (isNamedDeclaration(node)) {
|
|
setParent(node.name, node);
|
|
}
|
|
let message = symbol.flags & 2 /* BlockScopedVariable */ ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
let messageNeedsName = true;
|
|
if (symbol.flags & 384 /* Enum */ || includes & 384 /* Enum */) {
|
|
message = Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;
|
|
messageNeedsName = false;
|
|
}
|
|
let multipleDefaultExports = false;
|
|
if (length(symbol.declarations)) {
|
|
if (isDefaultExport) {
|
|
message = Diagnostics.A_module_cannot_have_multiple_default_exports;
|
|
messageNeedsName = false;
|
|
multipleDefaultExports = true;
|
|
} else {
|
|
if (symbol.declarations && symbol.declarations.length && (node.kind === 274 /* ExportAssignment */ && !node.isExportEquals)) {
|
|
message = Diagnostics.A_module_cannot_have_multiple_default_exports;
|
|
messageNeedsName = false;
|
|
multipleDefaultExports = true;
|
|
}
|
|
}
|
|
}
|
|
const relatedInformation = [];
|
|
if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 1 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
|
|
relatedInformation.push(createDiagnosticForNode2(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));
|
|
}
|
|
const declarationName = getNameOfDeclaration(node) || node;
|
|
forEach(symbol.declarations, (declaration, index) => {
|
|
const decl = getNameOfDeclaration(declaration) || declaration;
|
|
const diag3 = createDiagnosticForNode2(decl, message, messageNeedsName ? getDisplayName(declaration) : void 0);
|
|
file.bindDiagnostics.push(
|
|
multipleDefaultExports ? addRelatedInfo(diag3, createDiagnosticForNode2(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag3
|
|
);
|
|
if (multipleDefaultExports) {
|
|
relatedInformation.push(createDiagnosticForNode2(decl, Diagnostics.The_first_export_default_is_here));
|
|
}
|
|
});
|
|
const diag2 = createDiagnosticForNode2(declarationName, message, messageNeedsName ? getDisplayName(node) : void 0);
|
|
file.bindDiagnostics.push(addRelatedInfo(diag2, ...relatedInformation));
|
|
symbol = createSymbol(0 /* None */, name);
|
|
}
|
|
}
|
|
}
|
|
addDeclarationToSymbol(symbol, node, includes);
|
|
if (symbol.parent) {
|
|
Debug.assert(symbol.parent === parent2, "Existing symbol parent should match new one");
|
|
} else {
|
|
symbol.parent = parent2;
|
|
}
|
|
return symbol;
|
|
}
|
|
function declareModuleMember(node, symbolFlags, symbolExcludes) {
|
|
const hasExportModifier = !!(getCombinedModifierFlags(node) & 1 /* Export */) || jsdocTreatAsExported(node);
|
|
if (symbolFlags & 2097152 /* Alias */) {
|
|
if (node.kind === 278 /* ExportSpecifier */ || node.kind === 268 /* ImportEqualsDeclaration */ && hasExportModifier) {
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
} else {
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
} else {
|
|
if (isJSDocTypeAlias(node))
|
|
Debug.assert(isInJSFile(node));
|
|
if (!isAmbientModule(node) && (hasExportModifier || container.flags & 64 /* ExportContext */)) {
|
|
if (!container.locals || hasSyntacticModifier(node, 1024 /* Default */) && !getDeclarationName(node)) {
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
}
|
|
const exportKind = symbolFlags & 111551 /* Value */ ? 1048576 /* ExportValue */ : 0;
|
|
const local = declareSymbol(container.locals, void 0, node, exportKind, symbolExcludes);
|
|
local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
node.localSymbol = local;
|
|
return local;
|
|
} else {
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
}
|
|
function jsdocTreatAsExported(node) {
|
|
if (node.parent && isModuleDeclaration(node)) {
|
|
node = node.parent;
|
|
}
|
|
if (!isJSDocTypeAlias(node))
|
|
return false;
|
|
if (!isJSDocEnumTag(node) && !!node.fullName)
|
|
return true;
|
|
const declName = getNameOfDeclaration(node);
|
|
if (!declName)
|
|
return false;
|
|
if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent))
|
|
return true;
|
|
if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 1 /* Export */)
|
|
return true;
|
|
return false;
|
|
}
|
|
function bindContainer(node, containerFlags) {
|
|
const saveContainer = container;
|
|
const saveThisParentContainer = thisParentContainer;
|
|
const savedBlockScopeContainer = blockScopeContainer;
|
|
if (containerFlags & 1 /* IsContainer */) {
|
|
if (node.kind !== 216 /* ArrowFunction */) {
|
|
thisParentContainer = container;
|
|
}
|
|
container = blockScopeContainer = node;
|
|
if (containerFlags & 32 /* HasLocals */) {
|
|
container.locals = createSymbolTable();
|
|
}
|
|
addToContainerChain(container);
|
|
} else if (containerFlags & 2 /* IsBlockScopedContainer */) {
|
|
blockScopeContainer = node;
|
|
blockScopeContainer.locals = void 0;
|
|
}
|
|
if (containerFlags & 4 /* IsControlFlowContainer */) {
|
|
const saveCurrentFlow = currentFlow;
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const saveContinueTarget = currentContinueTarget;
|
|
const saveReturnTarget = currentReturnTarget;
|
|
const saveExceptionTarget = currentExceptionTarget;
|
|
const saveActiveLabelList = activeLabelList;
|
|
const saveHasExplicitReturn = hasExplicitReturn;
|
|
const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 512 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
if (!isImmediatelyInvoked) {
|
|
currentFlow = initFlowNode({ flags: 2 /* Start */ });
|
|
if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
|
|
currentFlow.node = node;
|
|
}
|
|
}
|
|
currentReturnTarget = isImmediatelyInvoked || node.kind === 173 /* Constructor */ || isInJSFile(node) && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */) ? createBranchLabel() : void 0;
|
|
currentExceptionTarget = void 0;
|
|
currentBreakTarget = void 0;
|
|
currentContinueTarget = void 0;
|
|
activeLabelList = void 0;
|
|
hasExplicitReturn = false;
|
|
bindChildren(node);
|
|
node.flags &= ~2816 /* ReachabilityAndEmitFlags */;
|
|
if (!(currentFlow.flags & 1 /* Unreachable */) && containerFlags & 8 /* IsFunctionLike */ && nodeIsPresent(node.body)) {
|
|
node.flags |= 256 /* HasImplicitReturn */;
|
|
if (hasExplicitReturn)
|
|
node.flags |= 512 /* HasExplicitReturn */;
|
|
node.endFlowNode = currentFlow;
|
|
}
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
node.flags |= emitFlags;
|
|
node.endFlowNode = currentFlow;
|
|
}
|
|
if (currentReturnTarget) {
|
|
addAntecedent(currentReturnTarget, currentFlow);
|
|
currentFlow = finishFlowLabel(currentReturnTarget);
|
|
if (node.kind === 173 /* Constructor */ || node.kind === 172 /* ClassStaticBlockDeclaration */ || isInJSFile(node) && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */)) {
|
|
node.returnFlowNode = currentFlow;
|
|
}
|
|
}
|
|
if (!isImmediatelyInvoked) {
|
|
currentFlow = saveCurrentFlow;
|
|
}
|
|
currentBreakTarget = saveBreakTarget;
|
|
currentContinueTarget = saveContinueTarget;
|
|
currentReturnTarget = saveReturnTarget;
|
|
currentExceptionTarget = saveExceptionTarget;
|
|
activeLabelList = saveActiveLabelList;
|
|
hasExplicitReturn = saveHasExplicitReturn;
|
|
} else if (containerFlags & 64 /* IsInterface */) {
|
|
seenThisKeyword = false;
|
|
bindChildren(node);
|
|
node.flags = seenThisKeyword ? node.flags | 128 /* ContainsThis */ : node.flags & ~128 /* ContainsThis */;
|
|
} else {
|
|
bindChildren(node);
|
|
}
|
|
container = saveContainer;
|
|
thisParentContainer = saveThisParentContainer;
|
|
blockScopeContainer = savedBlockScopeContainer;
|
|
}
|
|
function bindEachFunctionsFirst(nodes) {
|
|
bindEach(nodes, (n) => n.kind === 259 /* FunctionDeclaration */ ? bind(n) : void 0);
|
|
bindEach(nodes, (n) => n.kind !== 259 /* FunctionDeclaration */ ? bind(n) : void 0);
|
|
}
|
|
function bindEach(nodes, bindFunction = bind) {
|
|
if (nodes === void 0) {
|
|
return;
|
|
}
|
|
forEach(nodes, bindFunction);
|
|
}
|
|
function bindEachChild(node) {
|
|
forEachChild(node, bind, bindEach);
|
|
}
|
|
function bindChildren(node) {
|
|
const saveInAssignmentPattern = inAssignmentPattern;
|
|
inAssignmentPattern = false;
|
|
if (checkUnreachable(node)) {
|
|
bindEachChild(node);
|
|
bindJSDoc(node);
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
return;
|
|
}
|
|
if (node.kind >= 240 /* FirstStatement */ && node.kind <= 256 /* LastStatement */ && !options.allowUnreachableCode) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
switch (node.kind) {
|
|
case 244 /* WhileStatement */:
|
|
bindWhileStatement(node);
|
|
break;
|
|
case 243 /* DoStatement */:
|
|
bindDoStatement(node);
|
|
break;
|
|
case 245 /* ForStatement */:
|
|
bindForStatement(node);
|
|
break;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
bindForInOrForOfStatement(node);
|
|
break;
|
|
case 242 /* IfStatement */:
|
|
bindIfStatement(node);
|
|
break;
|
|
case 250 /* ReturnStatement */:
|
|
case 254 /* ThrowStatement */:
|
|
bindReturnOrThrow(node);
|
|
break;
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
bindBreakOrContinueStatement(node);
|
|
break;
|
|
case 255 /* TryStatement */:
|
|
bindTryStatement(node);
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
bindSwitchStatement(node);
|
|
break;
|
|
case 266 /* CaseBlock */:
|
|
bindCaseBlock(node);
|
|
break;
|
|
case 292 /* CaseClause */:
|
|
bindCaseClause(node);
|
|
break;
|
|
case 241 /* ExpressionStatement */:
|
|
bindExpressionStatement(node);
|
|
break;
|
|
case 253 /* LabeledStatement */:
|
|
bindLabeledStatement(node);
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
bindPrefixUnaryExpressionFlow(node);
|
|
break;
|
|
case 222 /* PostfixUnaryExpression */:
|
|
bindPostfixUnaryExpressionFlow(node);
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
bindDestructuringAssignmentFlow(node);
|
|
return;
|
|
}
|
|
bindBinaryExpressionFlow(node);
|
|
break;
|
|
case 217 /* DeleteExpression */:
|
|
bindDeleteExpressionFlow(node);
|
|
break;
|
|
case 224 /* ConditionalExpression */:
|
|
bindConditionalExpressionFlow(node);
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
bindVariableDeclarationFlow(node);
|
|
break;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
bindAccessExpressionFlow(node);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
bindCallExpressionFlow(node);
|
|
break;
|
|
case 232 /* NonNullExpression */:
|
|
bindNonNullExpressionFlow(node);
|
|
break;
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
bindJSDocTypeAlias(node);
|
|
break;
|
|
case 308 /* SourceFile */: {
|
|
bindEachFunctionsFirst(node.statements);
|
|
bind(node.endOfFileToken);
|
|
break;
|
|
}
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
bindEachFunctionsFirst(node.statements);
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
bindBindingElementFlow(node);
|
|
break;
|
|
case 166 /* Parameter */:
|
|
bindParameterFlow(node);
|
|
break;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 227 /* SpreadElement */:
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
default:
|
|
bindEachChild(node);
|
|
break;
|
|
}
|
|
bindJSDoc(node);
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
}
|
|
function isNarrowingExpression(expr) {
|
|
switch (expr.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 108 /* ThisKeyword */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return containsNarrowableReference(expr);
|
|
case 210 /* CallExpression */:
|
|
return hasNarrowableArgument(expr);
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return isNarrowingExpression(expr.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isNarrowingBinaryExpression(expr);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return expr.operator === 53 /* ExclamationToken */ && isNarrowingExpression(expr.operand);
|
|
case 218 /* TypeOfExpression */:
|
|
return isNarrowingExpression(expr.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowableReference(expr) {
|
|
return isDottedName(expr) || (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || isBinaryExpression(expr) && expr.operatorToken.kind === 27 /* CommaToken */ && isNarrowableReference(expr.right) || isElementAccessExpression(expr) && (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression) || isAssignmentExpression(expr) && isNarrowableReference(expr.left);
|
|
}
|
|
function containsNarrowableReference(expr) {
|
|
return isNarrowableReference(expr) || isOptionalChain(expr) && containsNarrowableReference(expr.expression);
|
|
}
|
|
function hasNarrowableArgument(expr) {
|
|
if (expr.arguments) {
|
|
for (const argument of expr.arguments) {
|
|
if (containsNarrowableReference(argument)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (expr.expression.kind === 208 /* PropertyAccessExpression */ && containsNarrowableReference(expr.expression.expression)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowingTypeofOperands(expr1, expr2) {
|
|
return isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && isStringLiteralLike(expr2);
|
|
}
|
|
function isNarrowingBinaryExpression(expr) {
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return containsNarrowableReference(expr.left);
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
|
|
case 102 /* InstanceOfKeyword */:
|
|
return isNarrowableOperand(expr.left);
|
|
case 101 /* InKeyword */:
|
|
return isNarrowingExpression(expr.right);
|
|
case 27 /* CommaToken */:
|
|
return isNarrowingExpression(expr.right);
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowableOperand(expr) {
|
|
switch (expr.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isNarrowableOperand(expr.expression);
|
|
case 223 /* BinaryExpression */:
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
return isNarrowableOperand(expr.left);
|
|
case 27 /* CommaToken */:
|
|
return isNarrowableOperand(expr.right);
|
|
}
|
|
}
|
|
return containsNarrowableReference(expr);
|
|
}
|
|
function createBranchLabel() {
|
|
return initFlowNode({ flags: 4 /* BranchLabel */, antecedents: void 0 });
|
|
}
|
|
function createLoopLabel() {
|
|
return initFlowNode({ flags: 8 /* LoopLabel */, antecedents: void 0 });
|
|
}
|
|
function createReduceLabel(target, antecedents, antecedent) {
|
|
return initFlowNode({ flags: 1024 /* ReduceLabel */, target, antecedents, antecedent });
|
|
}
|
|
function setFlowNodeReferenced(flow) {
|
|
flow.flags |= flow.flags & 2048 /* Referenced */ ? 4096 /* Shared */ : 2048 /* Referenced */;
|
|
}
|
|
function addAntecedent(label, antecedent) {
|
|
if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedents, antecedent)) {
|
|
(label.antecedents || (label.antecedents = [])).push(antecedent);
|
|
setFlowNodeReferenced(antecedent);
|
|
}
|
|
}
|
|
function createFlowCondition(flags, antecedent, expression) {
|
|
if (antecedent.flags & 1 /* Unreachable */) {
|
|
return antecedent;
|
|
}
|
|
if (!expression) {
|
|
return flags & 32 /* TrueCondition */ ? antecedent : unreachableFlow;
|
|
}
|
|
if ((expression.kind === 110 /* TrueKeyword */ && flags & 64 /* FalseCondition */ || expression.kind === 95 /* FalseKeyword */ && flags & 32 /* TrueCondition */) && !isExpressionOfOptionalChainRoot(expression) && !isNullishCoalesce(expression.parent)) {
|
|
return unreachableFlow;
|
|
}
|
|
if (!isNarrowingExpression(expression)) {
|
|
return antecedent;
|
|
}
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags, antecedent, node: expression });
|
|
}
|
|
function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags: 128 /* SwitchClause */, antecedent, switchStatement, clauseStart, clauseEnd });
|
|
}
|
|
function createFlowMutation(flags, antecedent, node) {
|
|
setFlowNodeReferenced(antecedent);
|
|
const result = initFlowNode({ flags, antecedent, node });
|
|
if (currentExceptionTarget) {
|
|
addAntecedent(currentExceptionTarget, result);
|
|
}
|
|
return result;
|
|
}
|
|
function createFlowCall(antecedent, node) {
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags: 512 /* Call */, antecedent, node });
|
|
}
|
|
function finishFlowLabel(flow) {
|
|
const antecedents = flow.antecedents;
|
|
if (!antecedents) {
|
|
return unreachableFlow;
|
|
}
|
|
if (antecedents.length === 1) {
|
|
return antecedents[0];
|
|
}
|
|
return flow;
|
|
}
|
|
function isStatementCondition(node) {
|
|
const parent2 = node.parent;
|
|
switch (parent2.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 243 /* DoStatement */:
|
|
return parent2.expression === node;
|
|
case 245 /* ForStatement */:
|
|
case 224 /* ConditionalExpression */:
|
|
return parent2.condition === node;
|
|
}
|
|
return false;
|
|
}
|
|
function isLogicalExpression(node) {
|
|
while (true) {
|
|
if (node.kind === 214 /* ParenthesizedExpression */) {
|
|
node = node.expression;
|
|
} else if (node.kind === 221 /* PrefixUnaryExpression */ && node.operator === 53 /* ExclamationToken */) {
|
|
node = node.operand;
|
|
} else {
|
|
return node.kind === 223 /* BinaryExpression */ && (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || node.operatorToken.kind === 56 /* BarBarToken */ || node.operatorToken.kind === 60 /* QuestionQuestionToken */);
|
|
}
|
|
}
|
|
}
|
|
function isLogicalAssignmentExpression(node) {
|
|
node = skipParentheses(node);
|
|
return isBinaryExpression(node) && isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind);
|
|
}
|
|
function isTopLevelLogicalExpression(node) {
|
|
while (isParenthesizedExpression(node.parent) || isPrefixUnaryExpression(node.parent) && node.parent.operator === 53 /* ExclamationToken */) {
|
|
node = node.parent;
|
|
}
|
|
return !isStatementCondition(node) && !isLogicalExpression(node.parent) && !(isOptionalChain(node.parent) && node.parent.expression === node);
|
|
}
|
|
function doWithConditionalBranches(action, value, trueTarget, falseTarget) {
|
|
const savedTrueTarget = currentTrueTarget;
|
|
const 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) && !(isOptionalChain(node) && isOutermostOptionalChain(node))) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindIterativeStatement(node, breakTarget, continueTarget) {
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const saveContinueTarget = currentContinueTarget;
|
|
currentBreakTarget = breakTarget;
|
|
currentContinueTarget = continueTarget;
|
|
bind(node);
|
|
currentBreakTarget = saveBreakTarget;
|
|
currentContinueTarget = saveContinueTarget;
|
|
}
|
|
function setContinueTarget(node, target) {
|
|
let label = activeLabelList;
|
|
while (label && node.parent.kind === 253 /* LabeledStatement */) {
|
|
label.continueTarget = target;
|
|
label = label.next;
|
|
node = node.parent;
|
|
}
|
|
return target;
|
|
}
|
|
function bindWhileStatement(node) {
|
|
const preWhileLabel = setContinueTarget(node, createLoopLabel());
|
|
const preBodyLabel = createBranchLabel();
|
|
const 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) {
|
|
const preDoLabel = createLoopLabel();
|
|
const preConditionLabel = setContinueTarget(node, createBranchLabel());
|
|
const 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) {
|
|
const preLoopLabel = setContinueTarget(node, createLoopLabel());
|
|
const preBodyLabel = createBranchLabel();
|
|
const 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) {
|
|
const preLoopLabel = setContinueTarget(node, createLoopLabel());
|
|
const postLoopLabel = createBranchLabel();
|
|
bind(node.expression);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = preLoopLabel;
|
|
if (node.kind === 247 /* ForOfStatement */) {
|
|
bind(node.awaitModifier);
|
|
}
|
|
addAntecedent(postLoopLabel, currentFlow);
|
|
bind(node.initializer);
|
|
if (node.initializer.kind !== 258 /* VariableDeclarationList */) {
|
|
bindAssignmentTargetFlow(node.initializer);
|
|
}
|
|
bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postLoopLabel);
|
|
}
|
|
function bindIfStatement(node) {
|
|
const thenLabel = createBranchLabel();
|
|
const elseLabel = createBranchLabel();
|
|
const 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 /* ReturnStatement */) {
|
|
hasExplicitReturn = true;
|
|
if (currentReturnTarget) {
|
|
addAntecedent(currentReturnTarget, currentFlow);
|
|
}
|
|
}
|
|
currentFlow = unreachableFlow;
|
|
}
|
|
function findActiveLabel(name) {
|
|
for (let label = activeLabelList; label; label = label.next) {
|
|
if (label.name === name) {
|
|
return label;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function bindBreakOrContinueFlow(node, breakTarget, continueTarget) {
|
|
const flowLabel = node.kind === 249 /* BreakStatement */ ? breakTarget : continueTarget;
|
|
if (flowLabel) {
|
|
addAntecedent(flowLabel, currentFlow);
|
|
currentFlow = unreachableFlow;
|
|
}
|
|
}
|
|
function bindBreakOrContinueStatement(node) {
|
|
bind(node.label);
|
|
if (node.label) {
|
|
const activeLabel = findActiveLabel(node.label.escapedText);
|
|
if (activeLabel) {
|
|
activeLabel.referenced = true;
|
|
bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);
|
|
}
|
|
} else {
|
|
bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);
|
|
}
|
|
}
|
|
function bindTryStatement(node) {
|
|
const saveReturnTarget = currentReturnTarget;
|
|
const saveExceptionTarget = currentExceptionTarget;
|
|
const normalExitLabel = createBranchLabel();
|
|
const returnLabel = createBranchLabel();
|
|
let exceptionLabel = createBranchLabel();
|
|
if (node.finallyBlock) {
|
|
currentReturnTarget = returnLabel;
|
|
}
|
|
addAntecedent(exceptionLabel, currentFlow);
|
|
currentExceptionTarget = exceptionLabel;
|
|
bind(node.tryBlock);
|
|
addAntecedent(normalExitLabel, currentFlow);
|
|
if (node.catchClause) {
|
|
currentFlow = finishFlowLabel(exceptionLabel);
|
|
exceptionLabel = createBranchLabel();
|
|
addAntecedent(exceptionLabel, currentFlow);
|
|
currentExceptionTarget = exceptionLabel;
|
|
bind(node.catchClause);
|
|
addAntecedent(normalExitLabel, currentFlow);
|
|
}
|
|
currentReturnTarget = saveReturnTarget;
|
|
currentExceptionTarget = saveExceptionTarget;
|
|
if (node.finallyBlock) {
|
|
const finallyLabel = createBranchLabel();
|
|
finallyLabel.antecedents = concatenate(concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
|
|
currentFlow = finallyLabel;
|
|
bind(node.finallyBlock);
|
|
if (currentFlow.flags & 1 /* Unreachable */) {
|
|
currentFlow = unreachableFlow;
|
|
} else {
|
|
if (currentReturnTarget && returnLabel.antecedents) {
|
|
addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
|
|
}
|
|
if (currentExceptionTarget && exceptionLabel.antecedents) {
|
|
addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow));
|
|
}
|
|
currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
|
|
}
|
|
} else {
|
|
currentFlow = finishFlowLabel(normalExitLabel);
|
|
}
|
|
}
|
|
function bindSwitchStatement(node) {
|
|
const postSwitchLabel = createBranchLabel();
|
|
bind(node.expression);
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const savePreSwitchCaseFlow = preSwitchCaseFlow;
|
|
currentBreakTarget = postSwitchLabel;
|
|
preSwitchCaseFlow = currentFlow;
|
|
bind(node.caseBlock);
|
|
addAntecedent(postSwitchLabel, currentFlow);
|
|
const hasDefault = forEach(node.caseBlock.clauses, (c) => c.kind === 293 /* DefaultClause */);
|
|
node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
|
|
if (!hasDefault) {
|
|
addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
|
|
}
|
|
currentBreakTarget = saveBreakTarget;
|
|
preSwitchCaseFlow = savePreSwitchCaseFlow;
|
|
currentFlow = finishFlowLabel(postSwitchLabel);
|
|
}
|
|
function bindCaseBlock(node) {
|
|
const clauses = node.clauses;
|
|
const isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
|
|
let fallthroughFlow = unreachableFlow;
|
|
for (let i = 0; i < clauses.length; i++) {
|
|
const clauseStart = i;
|
|
while (!clauses[i].statements.length && i + 1 < clauses.length) {
|
|
bind(clauses[i]);
|
|
i++;
|
|
}
|
|
const preCaseLabel = createBranchLabel();
|
|
addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow);
|
|
addAntecedent(preCaseLabel, fallthroughFlow);
|
|
currentFlow = finishFlowLabel(preCaseLabel);
|
|
const clause = clauses[i];
|
|
bind(clause);
|
|
fallthroughFlow = currentFlow;
|
|
if (!(currentFlow.flags & 1 /* Unreachable */) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
|
|
clause.fallthroughFlowNode = currentFlow;
|
|
}
|
|
}
|
|
}
|
|
function bindCaseClause(node) {
|
|
const saveCurrentFlow = currentFlow;
|
|
currentFlow = preSwitchCaseFlow;
|
|
bind(node.expression);
|
|
currentFlow = saveCurrentFlow;
|
|
bindEach(node.statements);
|
|
}
|
|
function bindExpressionStatement(node) {
|
|
bind(node.expression);
|
|
maybeBindExpressionFlowIfCall(node.expression);
|
|
}
|
|
function maybeBindExpressionFlowIfCall(node) {
|
|
if (node.kind === 210 /* CallExpression */) {
|
|
const call = node;
|
|
if (call.expression.kind !== 106 /* SuperKeyword */ && isDottedName(call.expression)) {
|
|
currentFlow = createFlowCall(currentFlow, call);
|
|
}
|
|
}
|
|
}
|
|
function bindLabeledStatement(node) {
|
|
const postStatementLabel = createBranchLabel();
|
|
activeLabelList = {
|
|
next: activeLabelList,
|
|
name: node.label.escapedText,
|
|
breakTarget: postStatementLabel,
|
|
continueTarget: void 0,
|
|
referenced: false
|
|
};
|
|
bind(node.label);
|
|
bind(node.statement);
|
|
if (!activeLabelList.referenced && !options.allowUnusedLabels) {
|
|
errorOrSuggestionOnNode(unusedLabelIsError(options), node.label, Diagnostics.Unused_label);
|
|
}
|
|
activeLabelList = activeLabelList.next;
|
|
addAntecedent(postStatementLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postStatementLabel);
|
|
}
|
|
function bindDestructuringTargetFlow(node) {
|
|
if (node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 63 /* EqualsToken */) {
|
|
bindAssignmentTargetFlow(node.left);
|
|
} else {
|
|
bindAssignmentTargetFlow(node);
|
|
}
|
|
}
|
|
function bindAssignmentTargetFlow(node) {
|
|
if (isNarrowableReference(node)) {
|
|
currentFlow = createFlowMutation(16 /* Assignment */, currentFlow, node);
|
|
} else if (node.kind === 206 /* ArrayLiteralExpression */) {
|
|
for (const e of node.elements) {
|
|
if (e.kind === 227 /* SpreadElement */) {
|
|
bindAssignmentTargetFlow(e.expression);
|
|
} else {
|
|
bindDestructuringTargetFlow(e);
|
|
}
|
|
}
|
|
} else if (node.kind === 207 /* ObjectLiteralExpression */) {
|
|
for (const p of node.properties) {
|
|
if (p.kind === 299 /* PropertyAssignment */) {
|
|
bindDestructuringTargetFlow(p.initializer);
|
|
} else if (p.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
bindAssignmentTargetFlow(p.name);
|
|
} else if (p.kind === 301 /* SpreadAssignment */) {
|
|
bindAssignmentTargetFlow(p.expression);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function bindLogicalLikeExpression(node, trueTarget, falseTarget) {
|
|
const preRightLabel = createBranchLabel();
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || node.operatorToken.kind === 76 /* AmpersandAmpersandEqualsToken */) {
|
|
bindCondition(node.left, preRightLabel, falseTarget);
|
|
} else {
|
|
bindCondition(node.left, trueTarget, preRightLabel);
|
|
}
|
|
currentFlow = finishFlowLabel(preRightLabel);
|
|
bind(node.operatorToken);
|
|
if (isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind)) {
|
|
doWithConditionalBranches(bind, node.right, trueTarget, falseTarget);
|
|
bindAssignmentTargetFlow(node.left);
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
} else {
|
|
bindCondition(node.right, trueTarget, falseTarget);
|
|
}
|
|
}
|
|
function bindPrefixUnaryExpressionFlow(node) {
|
|
if (node.operator === 53 /* ExclamationToken */) {
|
|
const saveTrueTarget = currentTrueTarget;
|
|
currentTrueTarget = currentFalseTarget;
|
|
currentFalseTarget = saveTrueTarget;
|
|
bindEachChild(node);
|
|
currentFalseTarget = currentTrueTarget;
|
|
currentTrueTarget = saveTrueTarget;
|
|
} else {
|
|
bindEachChild(node);
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
bindAssignmentTargetFlow(node.operand);
|
|
}
|
|
}
|
|
}
|
|
function bindPostfixUnaryExpressionFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* 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 createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, void 0);
|
|
function onEnter(node, state) {
|
|
if (state) {
|
|
state.stackIndex++;
|
|
setParent(node, parent);
|
|
const saveInStrictMode = inStrictMode;
|
|
bindWorker(node);
|
|
const saveParent = parent;
|
|
parent = node;
|
|
state.skip = false;
|
|
state.inStrictModeStack[state.stackIndex] = saveInStrictMode;
|
|
state.parentStack[state.stackIndex] = saveParent;
|
|
} else {
|
|
state = {
|
|
stackIndex: 0,
|
|
skip: false,
|
|
inStrictModeStack: [void 0],
|
|
parentStack: [void 0]
|
|
};
|
|
}
|
|
const operator = node.operatorToken.kind;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */ || isLogicalOrCoalescingAssignmentOperator(operator)) {
|
|
if (isTopLevelLogicalExpression(node)) {
|
|
const 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) {
|
|
const maybeBound = maybeBind2(left);
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
maybeBindExpressionFlowIfCall(left);
|
|
}
|
|
return maybeBound;
|
|
}
|
|
}
|
|
function onOperator(operatorToken, state, _node) {
|
|
if (!state.skip) {
|
|
bind(operatorToken);
|
|
}
|
|
}
|
|
function onRight(right, state, node) {
|
|
if (!state.skip) {
|
|
const maybeBound = maybeBind2(right);
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
maybeBindExpressionFlowIfCall(right);
|
|
}
|
|
return maybeBound;
|
|
}
|
|
}
|
|
function onExit(node, state) {
|
|
if (!state.skip) {
|
|
const operator = node.operatorToken.kind;
|
|
if (isAssignmentOperator(operator) && !isAssignmentTarget(node)) {
|
|
bindAssignmentTargetFlow(node.left);
|
|
if (operator === 63 /* EqualsToken */ && node.left.kind === 209 /* ElementAccessExpression */) {
|
|
const elementAccess = node.left;
|
|
if (isNarrowableOperand(elementAccess.expression)) {
|
|
currentFlow = createFlowMutation(256 /* ArrayMutation */, currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const savedInStrictMode = state.inStrictModeStack[state.stackIndex];
|
|
const savedParent = state.parentStack[state.stackIndex];
|
|
if (savedInStrictMode !== void 0) {
|
|
inStrictMode = savedInStrictMode;
|
|
}
|
|
if (savedParent !== void 0) {
|
|
parent = savedParent;
|
|
}
|
|
state.skip = false;
|
|
state.stackIndex--;
|
|
}
|
|
function maybeBind2(node) {
|
|
if (node && isBinaryExpression(node) && !isDestructuringAssignment(node)) {
|
|
return node;
|
|
}
|
|
bind(node);
|
|
}
|
|
}
|
|
function bindDeleteExpressionFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.expression.kind === 208 /* PropertyAccessExpression */) {
|
|
bindAssignmentTargetFlow(node.expression);
|
|
}
|
|
}
|
|
function bindConditionalExpressionFlow(node) {
|
|
const trueLabel = createBranchLabel();
|
|
const falseLabel = createBranchLabel();
|
|
const 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) {
|
|
const name = !isOmittedExpression(node) ? node.name : void 0;
|
|
if (isBindingPattern(name)) {
|
|
for (const child of name.elements) {
|
|
bindInitializedVariableFlow(child);
|
|
}
|
|
} else {
|
|
currentFlow = createFlowMutation(16 /* Assignment */, currentFlow, node);
|
|
}
|
|
}
|
|
function bindVariableDeclarationFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.initializer || isForInOrOfStatement(node.parent.parent)) {
|
|
bindInitializedVariableFlow(node);
|
|
}
|
|
}
|
|
function bindBindingElementFlow(node) {
|
|
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);
|
|
}
|
|
function bindInitializer(node) {
|
|
if (!node) {
|
|
return;
|
|
}
|
|
const entryFlow = currentFlow;
|
|
bind(node);
|
|
if (entryFlow === unreachableFlow || entryFlow === currentFlow) {
|
|
return;
|
|
}
|
|
const exitFlow = createBranchLabel();
|
|
addAntecedent(exitFlow, entryFlow);
|
|
addAntecedent(exitFlow, currentFlow);
|
|
currentFlow = finishFlowLabel(exitFlow);
|
|
}
|
|
function bindJSDocTypeAlias(node) {
|
|
bind(node.tagName);
|
|
if (node.kind !== 342 /* JSDocEnumTag */ && node.fullName) {
|
|
setParent(node.fullName, node);
|
|
setParentRecursive(node.fullName, false);
|
|
}
|
|
if (typeof node.comment !== "string") {
|
|
bindEach(node.comment);
|
|
}
|
|
}
|
|
function bindJSDocClassTag(node) {
|
|
bindEachChild(node);
|
|
const host = getHostSignatureFromJSDoc(node);
|
|
if (host && host.kind !== 171 /* MethodDeclaration */) {
|
|
addDeclarationToSymbol(host.symbol, host, 32 /* Class */);
|
|
}
|
|
}
|
|
function bindOptionalExpression(node, trueTarget, falseTarget) {
|
|
doWithConditionalBranches(bind, node, trueTarget, falseTarget);
|
|
if (!isOptionalChain(node) || isOutermostOptionalChain(node)) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindOptionalChainRest(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
bind(node.questionDotToken);
|
|
bind(node.name);
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
bind(node.questionDotToken);
|
|
bind(node.argumentExpression);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
bind(node.questionDotToken);
|
|
bindEach(node.typeArguments);
|
|
bindEach(node.arguments);
|
|
break;
|
|
}
|
|
}
|
|
function bindOptionalChain(node, trueTarget, falseTarget) {
|
|
const preChainLabel = isOptionalChainRoot(node) ? createBranchLabel() : void 0;
|
|
bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget);
|
|
if (preChainLabel) {
|
|
currentFlow = finishFlowLabel(preChainLabel);
|
|
}
|
|
doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget);
|
|
if (isOutermostOptionalChain(node)) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindOptionalChainFlow(node) {
|
|
if (isTopLevelLogicalExpression(node)) {
|
|
const postExpressionLabel = createBranchLabel();
|
|
bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
|
|
currentFlow = finishFlowLabel(postExpressionLabel);
|
|
} else {
|
|
bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
|
|
}
|
|
}
|
|
function bindNonNullExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
bindEachChild(node);
|
|
}
|
|
}
|
|
function bindAccessExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
bindEachChild(node);
|
|
}
|
|
}
|
|
function bindCallExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
const expr = skipParentheses(node.expression);
|
|
if (expr.kind === 215 /* FunctionExpression */ || expr.kind === 216 /* ArrowFunction */) {
|
|
bindEach(node.typeArguments);
|
|
bindEach(node.arguments);
|
|
bind(node.expression);
|
|
} else {
|
|
bindEachChild(node);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
currentFlow = createFlowCall(currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
if (node.expression.kind === 208 /* PropertyAccessExpression */) {
|
|
const propertyAccess = node.expression;
|
|
if (isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) {
|
|
currentFlow = createFlowMutation(256 /* ArrayMutation */, currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
function getContainerFlags(node) {
|
|
switch (node.kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 289 /* JsxAttributes */:
|
|
return 1 /* IsContainer */;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return 1 /* IsContainer */ | 64 /* IsInterface */;
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 197 /* MappedType */:
|
|
case 178 /* IndexSignature */:
|
|
return 1 /* IsContainer */ | 32 /* HasLocals */;
|
|
case 308 /* SourceFile */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */;
|
|
}
|
|
case 173 /* Constructor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 181 /* FunctionType */:
|
|
case 177 /* ConstructSignature */:
|
|
case 182 /* ConstructorType */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 16 /* IsFunctionExpression */;
|
|
case 265 /* ModuleBlock */:
|
|
return 4 /* IsControlFlowContainer */;
|
|
case 169 /* PropertyDeclaration */:
|
|
return node.initializer ? 4 /* IsControlFlowContainer */ : 0;
|
|
case 295 /* CatchClause */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 266 /* CaseBlock */:
|
|
return 2 /* IsBlockScopedContainer */;
|
|
case 238 /* Block */:
|
|
return isFunctionLike(node.parent) || isClassStaticBlockDeclaration(node.parent) ? 0 /* None */ : 2 /* IsBlockScopedContainer */;
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function addToContainerChain(next) {
|
|
if (lastContainer) {
|
|
lastContainer.nextContainer = next;
|
|
}
|
|
lastContainer = next;
|
|
}
|
|
function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
|
|
switch (container.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
return declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
case 308 /* SourceFile */:
|
|
return declareSourceFileMember(node, symbolFlags, symbolExcludes);
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
return declareClassMember(node, symbolFlags, symbolExcludes);
|
|
case 263 /* EnumDeclaration */:
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 289 /* JsxAttributes */:
|
|
return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 197 /* MappedType */:
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
function declareClassMember(node, symbolFlags, symbolExcludes) {
|
|
return 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 isExternalModule(file) ? declareModuleMember(node, symbolFlags, symbolExcludes) : declareSymbol(file.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
function hasExportDeclarations(node) {
|
|
const body = isSourceFile(node) ? node : tryCast(node.body, isModuleBlock);
|
|
return !!body && body.statements.some((s) => isExportDeclaration(s) || isExportAssignment(s));
|
|
}
|
|
function setExportContextFlag(node) {
|
|
if (node.flags & 16777216 /* Ambient */ && !hasExportDeclarations(node)) {
|
|
node.flags |= 64 /* ExportContext */;
|
|
} else {
|
|
node.flags &= ~64 /* ExportContext */;
|
|
}
|
|
}
|
|
function bindModuleDeclaration(node) {
|
|
setExportContextFlag(node);
|
|
if (isAmbientModule(node)) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
|
|
}
|
|
if (isModuleAugmentationExternal(node)) {
|
|
declareModuleSymbol(node);
|
|
} else {
|
|
let pattern;
|
|
if (node.name.kind === 10 /* StringLiteral */) {
|
|
const { text } = node.name;
|
|
pattern = tryParsePattern(text);
|
|
if (pattern === void 0) {
|
|
errorOnFirstToken(node.name, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
|
|
}
|
|
}
|
|
const symbol = declareSymbolAndAddToSymbolTable(node, 512 /* ValueModule */, 110735 /* ValueModuleExcludes */);
|
|
file.patternAmbientModules = append(file.patternAmbientModules, pattern && !isString(pattern) ? { pattern, symbol } : void 0);
|
|
}
|
|
} else {
|
|
const state = declareModuleSymbol(node);
|
|
if (state !== 0 /* NonInstantiated */) {
|
|
const { symbol } = node;
|
|
symbol.constEnumOnlyModule = !(symbol.flags & (16 /* Function */ | 32 /* Class */ | 256 /* RegularEnum */)) && state === 2 /* ConstEnumOnly */ && symbol.constEnumOnlyModule !== false;
|
|
}
|
|
}
|
|
}
|
|
function declareModuleSymbol(node) {
|
|
const state = getModuleInstanceState(node);
|
|
const instantiated = state !== 0 /* NonInstantiated */;
|
|
declareSymbolAndAddToSymbolTable(
|
|
node,
|
|
instantiated ? 512 /* ValueModule */ : 1024 /* NamespaceModule */,
|
|
instantiated ? 110735 /* ValueModuleExcludes */ : 0 /* NamespaceModuleExcludes */
|
|
);
|
|
return state;
|
|
}
|
|
function bindFunctionOrConstructorType(node) {
|
|
const symbol = createSymbol(131072 /* Signature */, getDeclarationName(node));
|
|
addDeclarationToSymbol(symbol, node, 131072 /* Signature */);
|
|
const typeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* TypeLiteral */);
|
|
typeLiteralSymbol.members = createSymbolTable();
|
|
typeLiteralSymbol.members.set(symbol.escapedName, symbol);
|
|
}
|
|
function bindObjectLiteralExpression(node) {
|
|
return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object" /* Object */);
|
|
}
|
|
function bindJsxAttributes(node) {
|
|
return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__jsxAttributes" /* JSXAttributes */);
|
|
}
|
|
function bindJsxAttribute(node, symbolFlags, symbolExcludes) {
|
|
return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
|
|
}
|
|
function bindAnonymousDeclaration(node, symbolFlags, name) {
|
|
const symbol = createSymbol(symbolFlags, name);
|
|
if (symbolFlags & (8 /* EnumMember */ | 106500 /* ClassMember */)) {
|
|
symbol.parent = container.symbol;
|
|
}
|
|
addDeclarationToSymbol(symbol, node, symbolFlags);
|
|
return symbol;
|
|
}
|
|
function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
|
|
switch (blockScopeContainer.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
if (isExternalOrCommonJsModule(container)) {
|
|
declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
break;
|
|
}
|
|
default:
|
|
if (!blockScopeContainer.locals) {
|
|
blockScopeContainer.locals = createSymbolTable();
|
|
addToContainerChain(blockScopeContainer);
|
|
}
|
|
declareSymbol(blockScopeContainer.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
function delayedBindJSDocTypedefTag() {
|
|
if (!delayedTypeAliases) {
|
|
return;
|
|
}
|
|
const saveContainer = container;
|
|
const saveLastContainer = lastContainer;
|
|
const saveBlockScopeContainer = blockScopeContainer;
|
|
const saveParent = parent;
|
|
const saveCurrentFlow = currentFlow;
|
|
for (const typeAlias of delayedTypeAliases) {
|
|
const host = typeAlias.parent.parent;
|
|
container = findAncestor(host.parent, (n) => !!(getContainerFlags(n) & 1 /* IsContainer */)) || file;
|
|
blockScopeContainer = getEnclosingBlockScopeContainer(host) || file;
|
|
currentFlow = initFlowNode({ flags: 2 /* Start */ });
|
|
parent = typeAlias;
|
|
bind(typeAlias.typeExpression);
|
|
const declName = getNameOfDeclaration(typeAlias);
|
|
if ((isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && isPropertyAccessEntityNameExpression(declName.parent)) {
|
|
const isTopLevel = isTopLevelNamespaceAssignment(declName.parent);
|
|
if (isTopLevel) {
|
|
bindPotentiallyMissingNamespaces(
|
|
file.symbol,
|
|
declName.parent,
|
|
isTopLevel,
|
|
!!findAncestor(declName, (d) => isPropertyAccessExpression(d) && d.name.escapedText === "prototype"),
|
|
false
|
|
);
|
|
const oldContainer = container;
|
|
switch (getAssignmentDeclarationPropertyAccessKind(declName.parent)) {
|
|
case 1 /* ExportsProperty */:
|
|
case 2 /* ModuleExports */:
|
|
if (!isExternalOrCommonJsModule(file)) {
|
|
container = void 0;
|
|
} else {
|
|
container = file;
|
|
}
|
|
break;
|
|
case 4 /* ThisProperty */:
|
|
container = declName.parent.expression;
|
|
break;
|
|
case 3 /* PrototypeProperty */:
|
|
container = declName.parent.expression.name;
|
|
break;
|
|
case 5 /* Property */:
|
|
container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file : isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name : declName.parent.expression;
|
|
break;
|
|
case 0 /* None */:
|
|
return Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration");
|
|
}
|
|
if (container) {
|
|
declareModuleMember(typeAlias, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
}
|
|
container = oldContainer;
|
|
}
|
|
} else if (isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 79 /* Identifier */) {
|
|
parent = typeAlias.parent;
|
|
bindBlockScopedDeclaration(typeAlias, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
} else {
|
|
bind(typeAlias.fullName);
|
|
}
|
|
}
|
|
container = saveContainer;
|
|
lastContainer = saveLastContainer;
|
|
blockScopeContainer = saveBlockScopeContainer;
|
|
parent = saveParent;
|
|
currentFlow = saveCurrentFlow;
|
|
}
|
|
function checkContextualIdentifier(node) {
|
|
if (!file.parseDiagnostics.length && !(node.flags & 16777216 /* Ambient */) && !(node.flags & 8388608 /* JSDoc */) && !isIdentifierName(node)) {
|
|
if (inStrictMode && node.originalKeywordKind >= 117 /* FirstFutureReservedWord */ && node.originalKeywordKind <= 125 /* LastFutureReservedWord */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
getStrictModeIdentifierMessage(node),
|
|
declarationNameToString(node)
|
|
));
|
|
} else if (node.originalKeywordKind === 133 /* AwaitKeyword */) {
|
|
if (isExternalModule(file) && isInTopLevelContext(node)) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module,
|
|
declarationNameToString(node)
|
|
));
|
|
} else if (node.flags & 32768 /* AwaitContext */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
} else if (node.originalKeywordKind === 125 /* YieldKeyword */ && node.flags & 8192 /* YieldContext */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function getStrictModeIdentifierMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
|
|
}
|
|
if (file.externalModuleIndicator) {
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
|
|
}
|
|
function checkPrivateIdentifier(node) {
|
|
if (node.escapedText === "#constructor") {
|
|
if (!file.parseDiagnostics.length) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.constructor_is_a_reserved_word,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeBinaryExpression(node) {
|
|
if (inStrictMode && isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operatorToken.kind)) {
|
|
checkStrictModeEvalOrArguments(node, node.left);
|
|
}
|
|
}
|
|
function checkStrictModeCatchClause(node) {
|
|
if (inStrictMode && node.variableDeclaration) {
|
|
checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
|
|
}
|
|
}
|
|
function checkStrictModeDeleteExpression(node) {
|
|
if (inStrictMode && node.expression.kind === 79 /* Identifier */) {
|
|
const span = getErrorSpanForNode(file, node.expression);
|
|
file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
|
|
}
|
|
}
|
|
function isEvalOrArgumentsIdentifier(node) {
|
|
return isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments");
|
|
}
|
|
function checkStrictModeEvalOrArguments(contextNode, name) {
|
|
if (name && name.kind === 79 /* Identifier */) {
|
|
const identifier = name;
|
|
if (isEvalOrArgumentsIdentifier(identifier)) {
|
|
const span = getErrorSpanForNode(file, name);
|
|
file.bindDiagnostics.push(createFileDiagnostic(
|
|
file,
|
|
span.start,
|
|
span.length,
|
|
getStrictModeEvalOrArgumentsMessage(contextNode),
|
|
idText(identifier)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function getStrictModeEvalOrArgumentsMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return 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 Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Invalid_use_of_0_in_strict_mode;
|
|
}
|
|
function checkStrictModeFunctionName(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
}
|
|
function getStrictModeBlockScopeFunctionDeclarationMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return 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 Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5;
|
|
}
|
|
function checkStrictModeFunctionDeclaration(node) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (blockScopeContainer.kind !== 308 /* SourceFile */ && blockScopeContainer.kind !== 264 /* ModuleDeclaration */ && !isFunctionLikeOrClassStaticBlockDeclaration(blockScopeContainer)) {
|
|
const errorSpan = getErrorSpanForNode(file, node);
|
|
file.bindDiagnostics.push(createFileDiagnostic(
|
|
file,
|
|
errorSpan.start,
|
|
errorSpan.length,
|
|
getStrictModeBlockScopeFunctionDeclarationMessage(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeNumericLiteral(node) {
|
|
if (languageVersion < 1 /* ES5 */ && inStrictMode && node.numericLiteralFlags & 32 /* Octal */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
|
|
}
|
|
}
|
|
function checkStrictModePostfixUnaryExpression(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.operand);
|
|
}
|
|
}
|
|
function checkStrictModePrefixUnaryExpression(node) {
|
|
if (inStrictMode) {
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
checkStrictModeEvalOrArguments(node, node.operand);
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeWithStatement(node) {
|
|
if (inStrictMode) {
|
|
errorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
|
|
}
|
|
}
|
|
function checkStrictModeLabeledStatement(node) {
|
|
if (inStrictMode && getEmitScriptTarget(options) >= 2 /* ES2015 */) {
|
|
if (isDeclarationStatement(node.statement) || isVariableStatement(node.statement)) {
|
|
errorOnFirstToken(node.label, Diagnostics.A_label_is_not_allowed_here);
|
|
}
|
|
}
|
|
}
|
|
function errorOnFirstToken(node, message, arg0, arg1, arg2) {
|
|
const span = getSpanOfTokenAtPosition(file, node.pos);
|
|
file.bindDiagnostics.push(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: getTokenPosOfNode(startNode, file), end: endNode.end }, message);
|
|
}
|
|
function addErrorOrSuggestionDiagnostic(isError, range, message) {
|
|
const diag2 = createFileDiagnostic(file, range.pos, range.end - range.pos, message);
|
|
if (isError) {
|
|
file.bindDiagnostics.push(diag2);
|
|
} else {
|
|
file.bindSuggestionDiagnostics = append(file.bindSuggestionDiagnostics, { ...diag2, category: 2 /* Suggestion */ });
|
|
}
|
|
}
|
|
function bind(node) {
|
|
if (!node) {
|
|
return;
|
|
}
|
|
setParent(node, parent);
|
|
if (tracing)
|
|
node.tracingPath = file.path;
|
|
const saveInStrictMode = inStrictMode;
|
|
bindWorker(node);
|
|
if (node.kind > 162 /* LastToken */) {
|
|
const saveParent = parent;
|
|
parent = node;
|
|
const containerFlags = getContainerFlags(node);
|
|
if (containerFlags === 0 /* None */) {
|
|
bindChildren(node);
|
|
} else {
|
|
bindContainer(node, containerFlags);
|
|
}
|
|
parent = saveParent;
|
|
} else {
|
|
const saveParent = parent;
|
|
if (node.kind === 1 /* EndOfFileToken */)
|
|
parent = node;
|
|
bindJSDoc(node);
|
|
parent = saveParent;
|
|
}
|
|
inStrictMode = saveInStrictMode;
|
|
}
|
|
function bindJSDoc(node) {
|
|
if (hasJSDocNodes(node)) {
|
|
if (isInJSFile(node)) {
|
|
for (const j of node.jsDoc) {
|
|
bind(j);
|
|
}
|
|
} else {
|
|
for (const j of node.jsDoc) {
|
|
setParent(j, node);
|
|
setParentRecursive(j, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function updateStrictModeStatementList(statements) {
|
|
if (!inStrictMode) {
|
|
for (const statement of statements) {
|
|
if (!isPrologueDirective(statement)) {
|
|
return;
|
|
}
|
|
if (isUseStrictPrologueDirective(statement)) {
|
|
inStrictMode = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isUseStrictPrologueDirective(node) {
|
|
const nodeText = getSourceTextOfNodeFromSourceFile(file, node.expression);
|
|
return nodeText === '"use strict"' || nodeText === "'use strict'";
|
|
}
|
|
function bindWorker(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
if (node.isInJSDocNamespace) {
|
|
let parentNode = node.parent;
|
|
while (parentNode && !isJSDocTypeAlias(parentNode)) {
|
|
parentNode = parentNode.parent;
|
|
}
|
|
bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
break;
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
if (currentFlow && (isExpression(node) || parent.kind === 300 /* ShorthandPropertyAssignment */)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
return checkContextualIdentifier(node);
|
|
case 163 /* QualifiedName */:
|
|
if (currentFlow && isPartOfTypeQuery(node)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
break;
|
|
case 233 /* MetaProperty */:
|
|
case 106 /* SuperKeyword */:
|
|
node.flowNode = currentFlow;
|
|
break;
|
|
case 80 /* PrivateIdentifier */:
|
|
return checkPrivateIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = node;
|
|
if (currentFlow && isNarrowableReference(expr)) {
|
|
expr.flowNode = currentFlow;
|
|
}
|
|
if (isSpecialPropertyDeclaration(expr)) {
|
|
bindSpecialPropertyDeclaration(expr);
|
|
}
|
|
if (isInJSFile(expr) && file.commonJsModuleIndicator && isModuleExportsAccessExpression(expr) && !lookupSymbolForName(blockScopeContainer, "module")) {
|
|
declareSymbol(
|
|
file.locals,
|
|
void 0,
|
|
expr.expression,
|
|
1 /* FunctionScopedVariable */ | 134217728 /* ModuleExports */,
|
|
111550 /* FunctionScopedVariableExcludes */
|
|
);
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
const specialKind = getAssignmentDeclarationKind(node);
|
|
switch (specialKind) {
|
|
case 1 /* ExportsProperty */:
|
|
bindExportsPropertyAssignment(node);
|
|
break;
|
|
case 2 /* ModuleExports */:
|
|
bindModuleExportsAssignment(node);
|
|
break;
|
|
case 3 /* PrototypeProperty */:
|
|
bindPrototypePropertyAssignment(node.left, node);
|
|
break;
|
|
case 6 /* Prototype */:
|
|
bindPrototypeAssignment(node);
|
|
break;
|
|
case 4 /* ThisProperty */:
|
|
bindThisPropertyAssignment(node);
|
|
break;
|
|
case 5 /* Property */:
|
|
const expression = node.left.expression;
|
|
if (isInJSFile(node) && isIdentifier(expression)) {
|
|
const symbol = lookupSymbolForName(blockScopeContainer, expression.escapedText);
|
|
if (isThisInitializedDeclaration(symbol == null ? void 0 : symbol.valueDeclaration)) {
|
|
bindThisPropertyAssignment(node);
|
|
break;
|
|
}
|
|
}
|
|
bindSpecialPropertyAssignment(node);
|
|
break;
|
|
case 0 /* None */:
|
|
break;
|
|
default:
|
|
Debug.fail("Unknown binary expression special property assignment kind");
|
|
}
|
|
return checkStrictModeBinaryExpression(node);
|
|
case 295 /* CatchClause */:
|
|
return checkStrictModeCatchClause(node);
|
|
case 217 /* DeleteExpression */:
|
|
return checkStrictModeDeleteExpression(node);
|
|
case 8 /* NumericLiteral */:
|
|
return checkStrictModeNumericLiteral(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return checkStrictModePostfixUnaryExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return checkStrictModePrefixUnaryExpression(node);
|
|
case 251 /* WithStatement */:
|
|
return checkStrictModeWithStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return checkStrictModeLabeledStatement(node);
|
|
case 194 /* ThisType */:
|
|
seenThisKeyword = true;
|
|
return;
|
|
case 179 /* TypePredicate */:
|
|
break;
|
|
case 165 /* TypeParameter */:
|
|
return bindTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return bindParameter(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return bindVariableDeclarationOrBindingElement(node);
|
|
case 205 /* BindingElement */:
|
|
node.flowNode = currentFlow;
|
|
return bindVariableDeclarationOrBindingElement(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return bindPropertyWorker(node);
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 0 /* PropertyExcludes */);
|
|
case 302 /* EnumMember */:
|
|
return bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 900095 /* EnumMemberExcludes */);
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return declareSymbolAndAddToSymbolTable(node, 131072 /* Signature */, 0 /* None */);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return bindPropertyOrMethodOrAccessor(
|
|
node,
|
|
8192 /* Method */ | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */),
|
|
isObjectLiteralMethod(node) ? 0 /* PropertyExcludes */ : 103359 /* MethodExcludes */
|
|
);
|
|
case 259 /* FunctionDeclaration */:
|
|
return bindFunctionDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return declareSymbolAndAddToSymbolTable(node, 16384 /* Constructor */, 0 /* None */);
|
|
case 174 /* GetAccessor */:
|
|
return bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 46015 /* GetAccessorExcludes */);
|
|
case 175 /* SetAccessor */:
|
|
return bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 78783 /* SetAccessorExcludes */);
|
|
case 181 /* FunctionType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 326 /* JSDocSignature */:
|
|
case 182 /* ConstructorType */:
|
|
return bindFunctionOrConstructorType(node);
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 197 /* MappedType */:
|
|
return bindAnonymousTypeWorker(node);
|
|
case 335 /* JSDocClassTag */:
|
|
return bindJSDocClassTag(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return bindObjectLiteralExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return bindFunctionExpression(node);
|
|
case 210 /* CallExpression */:
|
|
const assignmentKind = getAssignmentDeclarationKind(node);
|
|
switch (assignmentKind) {
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
return bindObjectDefinePropertyAssignment(node);
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
return bindObjectDefinePropertyExport(node);
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return bindObjectDefinePrototypeProperty(node);
|
|
case 0 /* None */:
|
|
break;
|
|
default:
|
|
return Debug.fail("Unknown call expression assignment declaration kind");
|
|
}
|
|
if (isInJSFile(node)) {
|
|
bindCallExpression(node);
|
|
}
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
inStrictMode = true;
|
|
return bindClassLikeDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return bindBlockScopedDeclaration(node, 64 /* Interface */, 788872 /* InterfaceExcludes */);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return bindBlockScopedDeclaration(node, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
case 263 /* EnumDeclaration */:
|
|
return bindEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return bindModuleDeclaration(node);
|
|
case 289 /* JsxAttributes */:
|
|
return bindJsxAttributes(node);
|
|
case 288 /* JsxAttribute */:
|
|
return bindJsxAttribute(node, 4 /* Property */, 0 /* PropertyExcludes */);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return bindNamespaceExportDeclaration(node);
|
|
case 270 /* ImportClause */:
|
|
return bindImportClause(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return bindExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return bindExportAssignment(node);
|
|
case 308 /* SourceFile */:
|
|
updateStrictModeStatementList(node.statements);
|
|
return bindSourceFileIfExternalModule();
|
|
case 238 /* Block */:
|
|
if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
|
|
return;
|
|
}
|
|
case 265 /* ModuleBlock */:
|
|
return updateStrictModeStatementList(node.statements);
|
|
case 343 /* JSDocParameterTag */:
|
|
if (node.parent.kind === 326 /* JSDocSignature */) {
|
|
return bindParameter(node);
|
|
}
|
|
if (node.parent.kind !== 325 /* JSDocTypeLiteral */) {
|
|
break;
|
|
}
|
|
case 350 /* JSDocPropertyTag */:
|
|
const propTag = node;
|
|
const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 319 /* JSDocOptionalType */ ? 4 /* Property */ | 16777216 /* Optional */ : 4 /* Property */;
|
|
return declareSymbolAndAddToSymbolTable(propTag, flags, 0 /* PropertyExcludes */);
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return (delayedTypeAliases || (delayedTypeAliases = [])).push(node);
|
|
}
|
|
}
|
|
function bindPropertyWorker(node) {
|
|
const isAutoAccessor = isAutoAccessorPropertyDeclaration(node);
|
|
const includes = isAutoAccessor ? 98304 /* Accessor */ : 4 /* Property */;
|
|
const excludes = isAutoAccessor ? 13247 /* AccessorExcludes */ : 0 /* PropertyExcludes */;
|
|
return bindPropertyOrMethodOrAccessor(node, includes | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */), excludes);
|
|
}
|
|
function bindAnonymousTypeWorker(node) {
|
|
return bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type" /* Type */);
|
|
}
|
|
function bindSourceFileIfExternalModule() {
|
|
setExportContextFlag(file);
|
|
if (isExternalModule(file)) {
|
|
bindSourceFileAsExternalModule();
|
|
} else if (isJsonSourceFile(file)) {
|
|
bindSourceFileAsExternalModule();
|
|
const originalSymbol = file.symbol;
|
|
declareSymbol(file.symbol.exports, file.symbol, file, 4 /* Property */, 67108863 /* All */);
|
|
file.symbol = originalSymbol;
|
|
}
|
|
}
|
|
function bindSourceFileAsExternalModule() {
|
|
bindAnonymousDeclaration(file, 512 /* ValueModule */, `"${removeFileExtension(file.fileName)}"`);
|
|
}
|
|
function bindExportAssignment(node) {
|
|
if (!container.symbol || !container.symbol.exports) {
|
|
bindAnonymousDeclaration(node, 111551 /* Value */, getDeclarationName(node));
|
|
} else {
|
|
const flags = exportAssignmentIsAlias(node) ? 2097152 /* Alias */ : 4 /* Property */;
|
|
const symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863 /* All */);
|
|
if (node.isExportEquals) {
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
}
|
|
}
|
|
function bindNamespaceExportDeclaration(node) {
|
|
if (some(node.modifiers)) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, Diagnostics.Modifiers_cannot_appear_here));
|
|
}
|
|
const diag2 = !isSourceFile(node.parent) ? Diagnostics.Global_module_exports_may_only_appear_at_top_level : !isExternalModule(node.parent) ? Diagnostics.Global_module_exports_may_only_appear_in_module_files : !node.parent.isDeclarationFile ? Diagnostics.Global_module_exports_may_only_appear_in_declaration_files : void 0;
|
|
if (diag2) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, diag2));
|
|
} else {
|
|
file.symbol.globalExports = file.symbol.globalExports || createSymbolTable();
|
|
declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
}
|
|
}
|
|
function bindExportDeclaration(node) {
|
|
if (!container.symbol || !container.symbol.exports) {
|
|
bindAnonymousDeclaration(node, 8388608 /* ExportStar */, getDeclarationName(node));
|
|
} else if (!node.exportClause) {
|
|
declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* ExportStar */, 0 /* None */);
|
|
} else if (isNamespaceExport(node.exportClause)) {
|
|
setParent(node.exportClause, node);
|
|
declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
}
|
|
}
|
|
function bindImportClause(node) {
|
|
if (node.name) {
|
|
declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* 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;
|
|
}
|
|
const symbol = forEachIdentifierInEntityName(node.arguments[0], void 0, (id, symbol2) => {
|
|
if (symbol2) {
|
|
addDeclarationToSymbol(symbol2, id, 1536 /* Module */ | 67108864 /* Assignment */);
|
|
}
|
|
return symbol2;
|
|
});
|
|
if (symbol) {
|
|
const flags = 4 /* Property */ | 1048576 /* ExportValue */;
|
|
declareSymbol(symbol.exports, symbol, node, flags, 0 /* None */);
|
|
}
|
|
}
|
|
function bindExportsPropertyAssignment(node) {
|
|
if (!setCommonJsModuleIndicator(node)) {
|
|
return;
|
|
}
|
|
const symbol = forEachIdentifierInEntityName(node.left.expression, void 0, (id, symbol2) => {
|
|
if (symbol2) {
|
|
addDeclarationToSymbol(symbol2, id, 1536 /* Module */ | 67108864 /* Assignment */);
|
|
}
|
|
return symbol2;
|
|
});
|
|
if (symbol) {
|
|
const isAlias = isAliasableExpression(node.right) && (isExportsIdentifier(node.left.expression) || isModuleExportsAccessExpression(node.left.expression));
|
|
const flags = isAlias ? 2097152 /* Alias */ : 4 /* Property */ | 1048576 /* ExportValue */;
|
|
setParent(node.left, node);
|
|
declareSymbol(symbol.exports, symbol, node.left, flags, 0 /* None */);
|
|
}
|
|
}
|
|
function bindModuleExportsAssignment(node) {
|
|
if (!setCommonJsModuleIndicator(node)) {
|
|
return;
|
|
}
|
|
const assignedExpression = getRightMostAssignedExpression(node.right);
|
|
if (isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) {
|
|
return;
|
|
}
|
|
if (isObjectLiteralExpression(assignedExpression) && every(assignedExpression.properties, isShorthandPropertyAssignment)) {
|
|
forEach(assignedExpression.properties, bindExportAssignedObjectMemberAlias);
|
|
return;
|
|
}
|
|
const flags = exportAssignmentIsAlias(node) ? 2097152 /* Alias */ : 4 /* Property */ | 1048576 /* ExportValue */ | 512 /* ValueModule */;
|
|
const symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864 /* Assignment */, 0 /* None */);
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
function bindExportAssignedObjectMemberAlias(node) {
|
|
declareSymbol(file.symbol.exports, file.symbol, node, 2097152 /* Alias */ | 67108864 /* Assignment */, 0 /* None */);
|
|
}
|
|
function bindThisPropertyAssignment(node) {
|
|
Debug.assert(isInJSFile(node));
|
|
const hasPrivateIdentifier = isBinaryExpression(node) && isPropertyAccessExpression(node.left) && isPrivateIdentifier(node.left.name) || isPropertyAccessExpression(node) && isPrivateIdentifier(node.name);
|
|
if (hasPrivateIdentifier) {
|
|
return;
|
|
}
|
|
const thisContainer = getThisContainer(node, false);
|
|
switch (thisContainer.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
let constructorSymbol = thisContainer.symbol;
|
|
if (isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const l = thisContainer.parent.left;
|
|
if (isBindableStaticAccessExpression(l) && isPrototypeAccess(l.expression)) {
|
|
constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer);
|
|
}
|
|
}
|
|
if (constructorSymbol && constructorSymbol.valueDeclaration) {
|
|
constructorSymbol.members = constructorSymbol.members || createSymbolTable();
|
|
if (hasDynamicName(node)) {
|
|
bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol, constructorSymbol.members);
|
|
} else {
|
|
declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 /* Property */ | 67108864 /* Assignment */, 0 /* PropertyExcludes */ & ~4 /* Property */);
|
|
}
|
|
addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
const containingClass = thisContainer.parent;
|
|
const symbolTable = isStatic(thisContainer) ? containingClass.symbol.exports : containingClass.symbol.members;
|
|
if (hasDynamicName(node)) {
|
|
bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol, symbolTable);
|
|
} else {
|
|
declareSymbol(symbolTable, containingClass.symbol, node, 4 /* Property */ | 67108864 /* Assignment */, 0 /* None */, true);
|
|
}
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
if (hasDynamicName(node)) {
|
|
break;
|
|
} else if (thisContainer.commonJsModuleIndicator) {
|
|
declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 /* Property */ | 1048576 /* ExportValue */, 0 /* None */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
|
|
}
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(thisContainer);
|
|
}
|
|
}
|
|
function bindDynamicallyNamedThisPropertyAssignment(node, symbol, symbolTable) {
|
|
declareSymbol(symbolTable, symbol, node, 4 /* Property */, 0 /* None */, true, true);
|
|
addLateBoundAssignmentDeclarationToSymbol(node, symbol);
|
|
}
|
|
function addLateBoundAssignmentDeclarationToSymbol(node, symbol) {
|
|
if (symbol) {
|
|
(symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = /* @__PURE__ */ new Map())).set(getNodeId(node), node);
|
|
}
|
|
}
|
|
function bindSpecialPropertyDeclaration(node) {
|
|
if (node.expression.kind === 108 /* ThisKeyword */) {
|
|
bindThisPropertyAssignment(node);
|
|
} else if (isBindableStaticAccessExpression(node) && node.parent.parent.kind === 308 /* SourceFile */) {
|
|
if (isPrototypeAccess(node.expression)) {
|
|
bindPrototypePropertyAssignment(node, node.parent);
|
|
} else {
|
|
bindStaticPropertyAssignment(node);
|
|
}
|
|
}
|
|
}
|
|
function bindPrototypeAssignment(node) {
|
|
setParent(node.left, node);
|
|
setParent(node.right, node);
|
|
bindPropertyAssignment(node.left.expression, node.left, false, true);
|
|
}
|
|
function bindObjectDefinePrototypeProperty(node) {
|
|
const namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression);
|
|
if (namespaceSymbol && namespaceSymbol.valueDeclaration) {
|
|
addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, true);
|
|
}
|
|
function bindPrototypePropertyAssignment(lhs, parent2) {
|
|
const classPrototype = lhs.expression;
|
|
const constructorFunction = classPrototype.expression;
|
|
setParent(constructorFunction, classPrototype);
|
|
setParent(classPrototype, lhs);
|
|
setParent(lhs, parent2);
|
|
bindPropertyAssignment(constructorFunction, lhs, true, true);
|
|
}
|
|
function bindObjectDefinePropertyAssignment(node) {
|
|
let namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]);
|
|
const isToplevel = node.parent.parent.kind === 308 /* SourceFile */;
|
|
namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, false, false);
|
|
bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, false);
|
|
}
|
|
function bindSpecialPropertyAssignment(node) {
|
|
var _a2;
|
|
const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
|
|
if (!isInJSFile(node) && !isFunctionSymbol(parentSymbol)) {
|
|
return;
|
|
}
|
|
const rootExpr = getLeftmostAccessExpression(node.left);
|
|
if (isIdentifier(rootExpr) && ((_a2 = lookupSymbolForName(container, rootExpr.escapedText)) == null ? void 0 : _a2.flags) & 2097152 /* Alias */) {
|
|
return;
|
|
}
|
|
setParent(node.left, node);
|
|
setParent(node.right, node);
|
|
if (isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) {
|
|
bindExportsPropertyAssignment(node);
|
|
} else if (hasDynamicName(node)) {
|
|
bindAnonymousDeclaration(node, 4 /* Property */ | 67108864 /* Assignment */, "__computed" /* Computed */);
|
|
const sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), false, false);
|
|
addLateBoundAssignmentDeclarationToSymbol(node, sym);
|
|
} else {
|
|
bindStaticPropertyAssignment(cast(node.left, isBindableStaticNameExpression));
|
|
}
|
|
}
|
|
function bindStaticPropertyAssignment(node) {
|
|
Debug.assert(!isIdentifier(node));
|
|
setParent(node.expression, node);
|
|
bindPropertyAssignment(node.expression, node, false, false);
|
|
}
|
|
function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) {
|
|
if ((namespaceSymbol == null ? void 0 : namespaceSymbol.flags) & 2097152 /* Alias */) {
|
|
return namespaceSymbol;
|
|
}
|
|
if (isToplevel && !isPrototypeProperty) {
|
|
const flags = 1536 /* Module */ | 67108864 /* Assignment */;
|
|
const excludeFlags = 110735 /* ValueModuleExcludes */ & ~67108864 /* Assignment */;
|
|
namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, (id, symbol, parent2) => {
|
|
if (symbol) {
|
|
addDeclarationToSymbol(symbol, id, flags);
|
|
return symbol;
|
|
} else {
|
|
const table = parent2 ? parent2.exports : file.jsGlobalAugmentations || (file.jsGlobalAugmentations = createSymbolTable());
|
|
return declareSymbol(table, parent2, id, flags, excludeFlags);
|
|
}
|
|
});
|
|
}
|
|
if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) {
|
|
addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
return namespaceSymbol;
|
|
}
|
|
function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) {
|
|
if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) {
|
|
return;
|
|
}
|
|
const symbolTable = isPrototypeProperty ? namespaceSymbol.members || (namespaceSymbol.members = createSymbolTable()) : namespaceSymbol.exports || (namespaceSymbol.exports = createSymbolTable());
|
|
let includes = 0 /* None */;
|
|
let excludes = 0 /* None */;
|
|
if (isFunctionLikeDeclaration(getAssignedExpandoInitializer(declaration))) {
|
|
includes = 8192 /* Method */;
|
|
excludes = 103359 /* MethodExcludes */;
|
|
} else if (isCallExpression(declaration) && isBindableObjectDefinePropertyCall(declaration)) {
|
|
if (some(declaration.arguments[2].properties, (p) => {
|
|
const id = getNameOfDeclaration(p);
|
|
return !!id && isIdentifier(id) && idText(id) === "set";
|
|
})) {
|
|
includes |= 65536 /* SetAccessor */ | 4 /* Property */;
|
|
excludes |= 78783 /* SetAccessorExcludes */;
|
|
}
|
|
if (some(declaration.arguments[2].properties, (p) => {
|
|
const id = getNameOfDeclaration(p);
|
|
return !!id && isIdentifier(id) && idText(id) === "get";
|
|
})) {
|
|
includes |= 32768 /* GetAccessor */ | 4 /* Property */;
|
|
excludes |= 46015 /* GetAccessorExcludes */;
|
|
}
|
|
}
|
|
if (includes === 0 /* None */) {
|
|
includes = 4 /* Property */;
|
|
excludes = 0 /* PropertyExcludes */;
|
|
}
|
|
declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864 /* Assignment */, excludes & ~67108864 /* Assignment */);
|
|
}
|
|
function isTopLevelNamespaceAssignment(propertyAccess) {
|
|
return isBinaryExpression(propertyAccess.parent) ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 308 /* SourceFile */ : propertyAccess.parent.parent.kind === 308 /* SourceFile */;
|
|
}
|
|
function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
|
|
let namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
|
|
const isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
|
|
namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
|
|
bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
|
|
}
|
|
function isExpandoSymbol(symbol) {
|
|
if (symbol.flags & (16 /* Function */ | 32 /* Class */ | 1024 /* NamespaceModule */)) {
|
|
return true;
|
|
}
|
|
const node = symbol.valueDeclaration;
|
|
if (node && isCallExpression(node)) {
|
|
return !!getAssignedExpandoInitializer(node);
|
|
}
|
|
let init = !node ? void 0 : isVariableDeclaration(node) ? node.initializer : isBinaryExpression(node) ? node.right : isPropertyAccessExpression(node) && isBinaryExpression(node.parent) ? node.parent.right : void 0;
|
|
init = init && getRightMostAssignedExpression(init);
|
|
if (init) {
|
|
const isPrototypeAssignment = isPrototypeAccess(isVariableDeclaration(node) ? node.name : isBinaryExpression(node) ? node.left : node);
|
|
return !!getExpandoInitializer(isBinaryExpression(init) && (init.operatorToken.kind === 56 /* BarBarToken */ || init.operatorToken.kind === 60 /* QuestionQuestionToken */) ? init.right : init, isPrototypeAssignment);
|
|
}
|
|
return false;
|
|
}
|
|
function getParentOfBinaryExpression(expr) {
|
|
while (isBinaryExpression(expr.parent)) {
|
|
expr = expr.parent;
|
|
}
|
|
return expr.parent;
|
|
}
|
|
function lookupSymbolForPropertyAccess(node, lookupContainer = container) {
|
|
if (isIdentifier(node)) {
|
|
return lookupSymbolForName(lookupContainer, node.escapedText);
|
|
} else {
|
|
const symbol = lookupSymbolForPropertyAccess(node.expression);
|
|
return symbol && symbol.exports && symbol.exports.get(getElementOrPropertyAccessName(node));
|
|
}
|
|
}
|
|
function forEachIdentifierInEntityName(e, parent2, action) {
|
|
if (isExportsOrModuleExportsOrAlias(file, e)) {
|
|
return file.symbol;
|
|
} else if (isIdentifier(e)) {
|
|
return action(e, lookupSymbolForPropertyAccess(e), parent2);
|
|
} else {
|
|
const s = forEachIdentifierInEntityName(e.expression, parent2, action);
|
|
const name = getNameOrArgument(e);
|
|
if (isPrivateIdentifier(name)) {
|
|
Debug.fail("unexpected PrivateIdentifier");
|
|
}
|
|
return action(name, s && s.exports && s.exports.get(getElementOrPropertyAccessName(e)), s);
|
|
}
|
|
}
|
|
function bindCallExpression(node) {
|
|
if (!file.commonJsModuleIndicator && isRequireCall(node, false)) {
|
|
setCommonJsModuleIndicator(node);
|
|
}
|
|
}
|
|
function bindClassLikeDeclaration(node) {
|
|
if (node.kind === 260 /* ClassDeclaration */) {
|
|
bindBlockScopedDeclaration(node, 32 /* Class */, 899503 /* ClassExcludes */);
|
|
} else {
|
|
const bindingName = node.name ? node.name.escapedText : "__class" /* Class */;
|
|
bindAnonymousDeclaration(node, 32 /* Class */, bindingName);
|
|
if (node.name) {
|
|
classifiableNames.add(node.name.escapedText);
|
|
}
|
|
}
|
|
const { symbol } = node;
|
|
const prototypeSymbol = createSymbol(4 /* Property */ | 4194304 /* Prototype */, "prototype");
|
|
const symbolExport = symbol.exports.get(prototypeSymbol.escapedName);
|
|
if (symbolExport) {
|
|
if (node.name) {
|
|
setParent(node.name, node);
|
|
}
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(symbolExport.declarations[0], Diagnostics.Duplicate_identifier_0, symbolName(prototypeSymbol)));
|
|
}
|
|
symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol);
|
|
prototypeSymbol.parent = symbol;
|
|
}
|
|
function bindEnumDeclaration(node) {
|
|
return isEnumConst(node) ? bindBlockScopedDeclaration(node, 128 /* ConstEnum */, 899967 /* ConstEnumExcludes */) : bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */);
|
|
}
|
|
function bindVariableDeclarationOrBindingElement(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
if (!isBindingPattern(node.name)) {
|
|
const possibleVariableDecl = node.kind === 257 /* VariableDeclaration */ ? node : node.parent.parent;
|
|
if (isInJSFile(node) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 1 /* Export */)) {
|
|
declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
} else if (isBlockOrCatchScoped(node)) {
|
|
bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 111551 /* BlockScopedVariableExcludes */);
|
|
} else if (isParameterDeclaration(node)) {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111551 /* ParameterExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
|
|
}
|
|
}
|
|
}
|
|
function bindParameter(node) {
|
|
if (node.kind === 343 /* JSDocParameterTag */ && container.kind !== 326 /* JSDocSignature */) {
|
|
return;
|
|
}
|
|
if (inStrictMode && !(node.flags & 16777216 /* Ambient */)) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, "__" + node.parent.parameters.indexOf(node));
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111551 /* ParameterExcludes */);
|
|
}
|
|
if (isParameterPropertyDeclaration(node, node.parent)) {
|
|
const classDeclaration = node.parent.parent;
|
|
declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */ | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */), 0 /* PropertyExcludes */);
|
|
}
|
|
}
|
|
function bindFunctionDeclaration(node) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
}
|
|
checkStrictModeFunctionName(node);
|
|
if (inStrictMode) {
|
|
checkStrictModeFunctionDeclaration(node);
|
|
bindBlockScopedDeclaration(node, 16 /* Function */, 110991 /* FunctionExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 16 /* Function */, 110991 /* FunctionExcludes */);
|
|
}
|
|
}
|
|
function bindFunctionExpression(node) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
}
|
|
if (currentFlow) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
checkStrictModeFunctionName(node);
|
|
const bindingName = node.name ? node.name.escapedText : "__function" /* Function */;
|
|
return bindAnonymousDeclaration(node, 16 /* Function */, bindingName);
|
|
}
|
|
function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */) && isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
if (currentFlow && isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
return hasDynamicName(node) ? bindAnonymousDeclaration(node, symbolFlags, "__computed" /* Computed */) : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
|
|
}
|
|
function getInferTypeContainer(node) {
|
|
const extendsType = findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && n.parent.extendsType === n);
|
|
return extendsType && extendsType.parent;
|
|
}
|
|
function bindTypeParameter(node) {
|
|
if (isJSDocTemplateTag(node.parent)) {
|
|
const container2 = getEffectiveContainerForJSDocTemplateTag(node.parent);
|
|
if (container2) {
|
|
if (!container2.locals) {
|
|
container2.locals = createSymbolTable();
|
|
}
|
|
declareSymbol(container2.locals, void 0, node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
}
|
|
} else if (node.parent.kind === 192 /* InferType */) {
|
|
const container2 = getInferTypeContainer(node.parent);
|
|
if (container2) {
|
|
if (!container2.locals) {
|
|
container2.locals = createSymbolTable();
|
|
}
|
|
declareSymbol(container2.locals, void 0, node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
} else {
|
|
bindAnonymousDeclaration(node, 262144 /* TypeParameter */, getDeclarationName(node));
|
|
}
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
}
|
|
}
|
|
function shouldReportErrorOnModuleDeclaration(node) {
|
|
const instanceState = getModuleInstanceState(node);
|
|
return instanceState === 1 /* Instantiated */ || instanceState === 2 /* ConstEnumOnly */ && shouldPreserveConstEnums(options);
|
|
}
|
|
function checkUnreachable(node) {
|
|
if (!(currentFlow.flags & 1 /* Unreachable */)) {
|
|
return false;
|
|
}
|
|
if (currentFlow === unreachableFlow) {
|
|
const reportError = isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || node.kind === 260 /* ClassDeclaration */ || node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node);
|
|
if (reportError) {
|
|
currentFlow = reportedUnreachableFlow;
|
|
if (!options.allowUnreachableCode) {
|
|
const isError = unreachableCodeIsError(options) && !(node.flags & 16777216 /* Ambient */) && (!isVariableStatement(node) || !!(getCombinedNodeFlags(node.declarationList) & 3 /* BlockScoped */) || node.declarationList.declarations.some((d) => !!d.initializer));
|
|
eachUnreachableRange(node, (start, end) => errorOrSuggestionOnRange(isError, start, end, Diagnostics.Unreachable_code_detected));
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function eachUnreachableRange(node, cb) {
|
|
if (isStatement(node) && isExecutableStatement(node) && isBlock(node.parent)) {
|
|
const { statements } = node.parent;
|
|
const slice = sliceAfter(statements, node);
|
|
getRangesWhere(slice, isExecutableStatement, (start, afterEnd) => cb(slice[start], slice[afterEnd - 1]));
|
|
} else {
|
|
cb(node, node);
|
|
}
|
|
}
|
|
function isExecutableStatement(s) {
|
|
return !isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !isEnumDeclaration(s) && !(isVariableStatement(s) && !(getCombinedNodeFlags(s) & (1 /* Let */ | 2 /* Const */)) && s.declarationList.declarations.some((d) => !d.initializer));
|
|
}
|
|
function isPurelyTypeDeclaration(s) {
|
|
switch (s.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
case 264 /* ModuleDeclaration */:
|
|
return getModuleInstanceState(s) !== 1 /* Instantiated */;
|
|
case 263 /* EnumDeclaration */:
|
|
return hasSyntacticModifier(s, 2048 /* Const */);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isExportsOrModuleExportsOrAlias(sourceFile, node) {
|
|
let i = 0;
|
|
const q = createQueue();
|
|
q.enqueue(node);
|
|
while (!q.isEmpty() && i < 100) {
|
|
i++;
|
|
node = q.dequeue();
|
|
if (isExportsIdentifier(node) || isModuleExportsAccessExpression(node)) {
|
|
return true;
|
|
} else if (isIdentifier(node)) {
|
|
const symbol = lookupSymbolForName(sourceFile, node.escapedText);
|
|
if (!!symbol && !!symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) {
|
|
const init = symbol.valueDeclaration.initializer;
|
|
q.enqueue(init);
|
|
if (isAssignmentExpression(init, true)) {
|
|
q.enqueue(init.left);
|
|
q.enqueue(init.right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function lookupSymbolForName(container, name) {
|
|
const local = container.locals && container.locals.get(name);
|
|
if (local) {
|
|
return local.exportSymbol || local;
|
|
}
|
|
if (isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) {
|
|
return container.jsGlobalAugmentations.get(name);
|
|
}
|
|
return container.symbol && container.symbol.exports && container.symbol.exports.get(name);
|
|
}
|
|
|
|
// src/compiler/symbolWalker.ts
|
|
function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getConstraintOfTypeParameter, getFirstIdentifier2, getTypeArguments) {
|
|
return getSymbolWalker;
|
|
function getSymbolWalker(accept = () => true) {
|
|
const visitedTypes = [];
|
|
const visitedSymbols = [];
|
|
return {
|
|
walkType: (type) => {
|
|
try {
|
|
visitType(type);
|
|
return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
|
|
} finally {
|
|
clear(visitedTypes);
|
|
clear(visitedSymbols);
|
|
}
|
|
},
|
|
walkSymbol: (symbol) => {
|
|
try {
|
|
visitSymbol(symbol);
|
|
return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
|
|
} finally {
|
|
clear(visitedTypes);
|
|
clear(visitedSymbols);
|
|
}
|
|
}
|
|
};
|
|
function visitType(type) {
|
|
if (!type) {
|
|
return;
|
|
}
|
|
if (visitedTypes[type.id]) {
|
|
return;
|
|
}
|
|
visitedTypes[type.id] = type;
|
|
const shouldBail = visitSymbol(type.symbol);
|
|
if (shouldBail)
|
|
return;
|
|
if (type.flags & 524288 /* Object */) {
|
|
const objectType = type;
|
|
const objectFlags = objectType.objectFlags;
|
|
if (objectFlags & 4 /* Reference */) {
|
|
visitTypeReference(type);
|
|
}
|
|
if (objectFlags & 32 /* Mapped */) {
|
|
visitMappedType(type);
|
|
}
|
|
if (objectFlags & (1 /* Class */ | 2 /* Interface */)) {
|
|
visitInterfaceType(type);
|
|
}
|
|
if (objectFlags & (8 /* Tuple */ | 16 /* Anonymous */)) {
|
|
visitObjectType(objectType);
|
|
}
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
visitTypeParameter(type);
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
visitUnionOrIntersectionType(type);
|
|
}
|
|
if (type.flags & 4194304 /* Index */) {
|
|
visitIndexType(type);
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
visitIndexedAccessType(type);
|
|
}
|
|
}
|
|
function visitTypeReference(type) {
|
|
visitType(type.target);
|
|
forEach(getTypeArguments(type), visitType);
|
|
}
|
|
function visitTypeParameter(type) {
|
|
visitType(getConstraintOfTypeParameter(type));
|
|
}
|
|
function visitUnionOrIntersectionType(type) {
|
|
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) {
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (typePredicate) {
|
|
visitType(typePredicate.type);
|
|
}
|
|
forEach(signature.typeParameters, visitType);
|
|
for (const parameter of signature.parameters) {
|
|
visitSymbol(parameter);
|
|
}
|
|
visitType(getRestTypeOfSignature(signature));
|
|
visitType(getReturnTypeOfSignature(signature));
|
|
}
|
|
function visitInterfaceType(interfaceT) {
|
|
visitObjectType(interfaceT);
|
|
forEach(interfaceT.typeParameters, visitType);
|
|
forEach(getBaseTypes(interfaceT), visitType);
|
|
visitType(interfaceT.thisType);
|
|
}
|
|
function visitObjectType(type) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
for (const info of resolved.indexInfos) {
|
|
visitType(info.keyType);
|
|
visitType(info.type);
|
|
}
|
|
for (const signature of resolved.callSignatures) {
|
|
visitSignature(signature);
|
|
}
|
|
for (const signature of resolved.constructSignatures) {
|
|
visitSignature(signature);
|
|
}
|
|
for (const p of resolved.properties) {
|
|
visitSymbol(p);
|
|
}
|
|
}
|
|
function visitSymbol(symbol) {
|
|
if (!symbol) {
|
|
return false;
|
|
}
|
|
const symbolId = getSymbolId(symbol);
|
|
if (visitedSymbols[symbolId]) {
|
|
return false;
|
|
}
|
|
visitedSymbols[symbolId] = symbol;
|
|
if (!accept(symbol)) {
|
|
return true;
|
|
}
|
|
const t = getTypeOfSymbol(symbol);
|
|
visitType(t);
|
|
if (symbol.exports) {
|
|
symbol.exports.forEach(visitSymbol);
|
|
}
|
|
forEach(symbol.declarations, (d) => {
|
|
if (d.type && d.type.kind === 183 /* TypeQuery */) {
|
|
const query = d.type;
|
|
const entity = getResolvedSymbol(getFirstIdentifier2(query.exprName));
|
|
visitSymbol(entity);
|
|
}
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/moduleSpecifiers.ts
|
|
function getPreferences(host, { importModuleSpecifierPreference, importModuleSpecifierEnding }, compilerOptions, importingSourceFile) {
|
|
return {
|
|
relativePreference: importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
|
|
ending: getEnding()
|
|
};
|
|
function getEnding() {
|
|
switch (importModuleSpecifierEnding) {
|
|
case "minimal":
|
|
return 0 /* Minimal */;
|
|
case "index":
|
|
return 1 /* Index */;
|
|
case "js":
|
|
return 2 /* JsExtension */;
|
|
default:
|
|
return usesJsExtensionOnImports(importingSourceFile) || isFormatRequiringExtensions(compilerOptions, importingSourceFile.path, host) ? 2 /* JsExtension */ : getEmitModuleResolutionKind(compilerOptions) !== 2 /* NodeJs */ ? 1 /* Index */ : 0 /* Minimal */;
|
|
}
|
|
}
|
|
}
|
|
function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) {
|
|
var _a2;
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
return false;
|
|
}
|
|
return getImpliedNodeFormatForFile(importingSourceFileName, (_a2 = host.getPackageJsonInfoCache) == null ? void 0 : _a2.call(host), getModuleResolutionHost(host), compilerOptions) !== 1 /* CommonJS */;
|
|
}
|
|
function getModuleResolutionHost(host) {
|
|
var _a2;
|
|
return {
|
|
fileExists: host.fileExists,
|
|
readFile: Debug.checkDefined(host.readFile),
|
|
directoryExists: host.directoryExists,
|
|
getCurrentDirectory: host.getCurrentDirectory,
|
|
realpath: host.realpath,
|
|
useCaseSensitiveFileNames: (_a2 = host.useCaseSensitiveFileNames) == null ? void 0 : _a2.call(host)
|
|
};
|
|
}
|
|
function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, options = {}) {
|
|
return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {}, options);
|
|
}
|
|
function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, preferences, userPreferences, options = {}) {
|
|
const info = getInfo(importingSourceFileName, host);
|
|
const modulePaths = getAllModulePaths(importingSourceFileName, toFileName2, host, userPreferences, options);
|
|
return firstDefined(modulePaths, (modulePath) => tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, void 0, options.overrideImportMode)) || getLocalModuleSpecifier(toFileName2, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
|
|
}
|
|
function tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options = {}) {
|
|
var _a2;
|
|
const moduleSourceFile = getSourceFileOfModule(moduleSymbol);
|
|
if (!moduleSourceFile) {
|
|
return emptyArray;
|
|
}
|
|
const cache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
const cached = cache == null ? void 0 : cache.get(importingSourceFile.path, moduleSourceFile.path, userPreferences, options);
|
|
return [cached == null ? void 0 : cached.moduleSpecifiers, moduleSourceFile, cached == null ? void 0 : cached.modulePaths, cache];
|
|
}
|
|
function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
return getModuleSpecifiersWithCacheInfo(
|
|
moduleSymbol,
|
|
checker,
|
|
compilerOptions,
|
|
importingSourceFile,
|
|
host,
|
|
userPreferences,
|
|
options
|
|
).moduleSpecifiers;
|
|
}
|
|
function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
let computedWithoutCache = false;
|
|
const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker);
|
|
if (ambient)
|
|
return { moduleSpecifiers: [ambient], computedWithoutCache };
|
|
let [specifiers, moduleSourceFile, modulePaths, cache] = tryGetModuleSpecifiersFromCacheWorker(
|
|
moduleSymbol,
|
|
importingSourceFile,
|
|
host,
|
|
userPreferences,
|
|
options
|
|
);
|
|
if (specifiers)
|
|
return { moduleSpecifiers: specifiers, computedWithoutCache };
|
|
if (!moduleSourceFile)
|
|
return { moduleSpecifiers: emptyArray, computedWithoutCache };
|
|
computedWithoutCache = true;
|
|
modulePaths || (modulePaths = getAllModulePathsWorker(importingSourceFile.path, moduleSourceFile.originalFileName, host));
|
|
const result = computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options);
|
|
cache == null ? void 0 : cache.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, modulePaths, result);
|
|
return { moduleSpecifiers: result, computedWithoutCache };
|
|
}
|
|
function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
const info = getInfo(importingSourceFile.path, host);
|
|
const preferences = getPreferences(host, userPreferences, compilerOptions, importingSourceFile);
|
|
const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
|
|
host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
|
|
(reason) => {
|
|
if (reason.kind !== 3 /* Import */ || reason.file !== importingSourceFile.path)
|
|
return void 0;
|
|
if (importingSourceFile.impliedNodeFormat && importingSourceFile.impliedNodeFormat !== getModeForResolutionAtIndex(importingSourceFile, reason.index))
|
|
return void 0;
|
|
const specifier = getModuleNameStringLiteralAt(importingSourceFile, reason.index).text;
|
|
return preferences.relativePreference !== 1 /* NonRelative */ || !pathIsRelative(specifier) ? specifier : void 0;
|
|
}
|
|
));
|
|
if (existingSpecifier) {
|
|
const moduleSpecifiers = [existingSpecifier];
|
|
return moduleSpecifiers;
|
|
}
|
|
const importedFileIsInNodeModules = some(modulePaths, (p) => p.isInNodeModules);
|
|
let nodeModulesSpecifiers;
|
|
let pathsSpecifiers;
|
|
let redirectPathsSpecifiers;
|
|
let relativeSpecifiers;
|
|
for (const modulePath of modulePaths) {
|
|
const specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, void 0, options.overrideImportMode);
|
|
nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
|
|
if (specifier && modulePath.isRedirect) {
|
|
return nodeModulesSpecifiers;
|
|
}
|
|
if (!specifier) {
|
|
const local = getLocalModuleSpecifier(
|
|
modulePath.path,
|
|
info,
|
|
compilerOptions,
|
|
host,
|
|
options.overrideImportMode || importingSourceFile.impliedNodeFormat,
|
|
preferences,
|
|
modulePath.isRedirect
|
|
);
|
|
if (!local) {
|
|
continue;
|
|
}
|
|
if (modulePath.isRedirect) {
|
|
redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
|
|
} else if (pathIsBareSpecifier(local)) {
|
|
pathsSpecifiers = append(pathsSpecifiers, local);
|
|
} else if (!importedFileIsInNodeModules || modulePath.isInNodeModules) {
|
|
relativeSpecifiers = append(relativeSpecifiers, local);
|
|
}
|
|
}
|
|
}
|
|
return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? redirectPathsSpecifiers : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : Debug.checkDefined(relativeSpecifiers);
|
|
}
|
|
function getInfo(importingSourceFileName, host) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true);
|
|
const sourceDirectory = getDirectoryPath(importingSourceFileName);
|
|
return { getCanonicalFileName, importingSourceFileName, sourceDirectory };
|
|
}
|
|
function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { ending, relativePreference }, pathsOnly) {
|
|
const { baseUrl, paths, rootDirs } = compilerOptions;
|
|
if (pathsOnly && !paths) {
|
|
return void 0;
|
|
}
|
|
const { sourceDirectory, getCanonicalFileName } = info;
|
|
const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
|
|
if (!baseUrl && !paths || relativePreference === 0 /* Relative */) {
|
|
return pathsOnly ? void 0 : relativePath;
|
|
}
|
|
const baseDirectory = getNormalizedAbsolutePath(getPathsBasePath(compilerOptions, host) || baseUrl, host.getCurrentDirectory());
|
|
const relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseDirectory, getCanonicalFileName);
|
|
if (!relativeToBaseUrl) {
|
|
return pathsOnly ? void 0 : relativePath;
|
|
}
|
|
const fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, getAllowedEndings(ending, compilerOptions, importMode), host, compilerOptions);
|
|
if (pathsOnly) {
|
|
return fromPaths;
|
|
}
|
|
const maybeNonRelative = fromPaths === void 0 && baseUrl !== void 0 ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
|
|
if (!maybeNonRelative) {
|
|
return relativePath;
|
|
}
|
|
if (relativePreference === 1 /* NonRelative */ && !pathIsRelative(maybeNonRelative)) {
|
|
return maybeNonRelative;
|
|
}
|
|
if (relativePreference === 3 /* ExternalNonRelative */ && !pathIsRelative(maybeNonRelative)) {
|
|
const projectDirectory = compilerOptions.configFilePath ? toPath(getDirectoryPath(compilerOptions.configFilePath), host.getCurrentDirectory(), info.getCanonicalFileName) : info.getCanonicalFileName(host.getCurrentDirectory());
|
|
const modulePath = toPath(moduleFileName, projectDirectory, getCanonicalFileName);
|
|
const sourceIsInternal = startsWith(sourceDirectory, projectDirectory);
|
|
const targetIsInternal = startsWith(modulePath, projectDirectory);
|
|
if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
|
|
return maybeNonRelative;
|
|
}
|
|
const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
|
|
const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
|
|
if (nearestSourcePackageJson !== nearestTargetPackageJson) {
|
|
return maybeNonRelative;
|
|
}
|
|
return relativePath;
|
|
}
|
|
return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
|
|
}
|
|
function countPathComponents(path) {
|
|
let count = 0;
|
|
for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
|
|
if (path.charCodeAt(i) === 47 /* slash */)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
function usesJsExtensionOnImports({ imports }) {
|
|
return firstDefined(imports, ({ text }) => pathIsRelative(text) ? hasJSFileExtension(text) : void 0) || false;
|
|
}
|
|
function comparePathsByRedirectAndNumberOfDirectorySeparators(a, b) {
|
|
return compareBooleans(b.isRedirect, a.isRedirect) || compareNumberOfDirectorySeparators(a.path, b.path);
|
|
}
|
|
function getNearestAncestorDirectoryWithPackageJson(host, fileName) {
|
|
if (host.getNearestAncestorDirectoryWithPackageJson) {
|
|
return host.getNearestAncestorDirectoryWithPackageJson(fileName);
|
|
}
|
|
return !!forEachAncestorDirectory(fileName, (directory) => {
|
|
return host.fileExists(combinePaths(directory, "package.json")) ? true : void 0;
|
|
});
|
|
}
|
|
function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) {
|
|
var _a2;
|
|
const getCanonicalFileName = hostGetCanonicalFileName(host);
|
|
const cwd = host.getCurrentDirectory();
|
|
const referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : void 0;
|
|
const importedPath = toPath(importedFileName, cwd, getCanonicalFileName);
|
|
const redirects = host.redirectTargetsMap.get(importedPath) || emptyArray;
|
|
const importedFileNames = [...referenceRedirect ? [referenceRedirect] : emptyArray, importedFileName, ...redirects];
|
|
const targets = importedFileNames.map((f) => getNormalizedAbsolutePath(f, cwd));
|
|
let shouldFilterIgnoredPaths = !every(targets, containsIgnoredPath);
|
|
if (!preferSymlinks) {
|
|
const result2 = forEach(targets, (p) => !(shouldFilterIgnoredPaths && containsIgnoredPath(p)) && cb(p, referenceRedirect === p));
|
|
if (result2)
|
|
return result2;
|
|
}
|
|
const symlinkedDirectories = (_a2 = host.getSymlinkCache) == null ? void 0 : _a2.call(host).getSymlinkedDirectoriesByRealpath();
|
|
const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd);
|
|
const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(fullImportedFileName), (realPathDirectory) => {
|
|
const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName)));
|
|
if (!symlinkDirectories)
|
|
return void 0;
|
|
if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) {
|
|
return false;
|
|
}
|
|
return forEach(targets, (target) => {
|
|
if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
|
|
return;
|
|
}
|
|
const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
|
|
for (const symlinkDirectory of symlinkDirectories) {
|
|
const option = resolvePath(symlinkDirectory, relative);
|
|
const result2 = cb(option, target === referenceRedirect);
|
|
shouldFilterIgnoredPaths = true;
|
|
if (result2)
|
|
return result2;
|
|
}
|
|
});
|
|
});
|
|
return result || (preferSymlinks ? forEach(targets, (p) => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? void 0 : cb(p, p === referenceRedirect)) : void 0);
|
|
}
|
|
function getAllModulePaths(importingFilePath, importedFileName, host, preferences, options = {}) {
|
|
var _a2;
|
|
const importedFilePath = toPath(importedFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
|
|
const cache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
if (cache) {
|
|
const cached = cache.get(importingFilePath, importedFilePath, preferences, options);
|
|
if (cached == null ? void 0 : cached.modulePaths)
|
|
return cached.modulePaths;
|
|
}
|
|
const modulePaths = getAllModulePathsWorker(importingFilePath, importedFileName, host);
|
|
if (cache) {
|
|
cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
|
|
}
|
|
return modulePaths;
|
|
}
|
|
function getAllModulePathsWorker(importingFileName, importedFileName, host) {
|
|
const getCanonicalFileName = hostGetCanonicalFileName(host);
|
|
const allFileNames = /* @__PURE__ */ new Map();
|
|
let importedFileFromNodeModules = false;
|
|
forEachFileNameOfModule(
|
|
importingFileName,
|
|
importedFileName,
|
|
host,
|
|
true,
|
|
(path, isRedirect) => {
|
|
const isInNodeModules = pathContainsNodeModules(path);
|
|
allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules });
|
|
importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
|
|
}
|
|
);
|
|
const sortedPaths = [];
|
|
for (let directory = getDirectoryPath(importingFileName); allFileNames.size !== 0; ) {
|
|
const directoryStart = ensureTrailingDirectorySeparator(directory);
|
|
let pathsInDirectory;
|
|
allFileNames.forEach(({ path, isRedirect, isInNodeModules }, fileName) => {
|
|
if (startsWith(path, directoryStart)) {
|
|
(pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
|
|
allFileNames.delete(fileName);
|
|
}
|
|
});
|
|
if (pathsInDirectory) {
|
|
if (pathsInDirectory.length > 1) {
|
|
pathsInDirectory.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
|
|
}
|
|
sortedPaths.push(...pathsInDirectory);
|
|
}
|
|
const newDirectory = getDirectoryPath(directory);
|
|
if (newDirectory === directory)
|
|
break;
|
|
directory = newDirectory;
|
|
}
|
|
if (allFileNames.size) {
|
|
const remainingPaths = arrayFrom(allFileNames.values());
|
|
if (remainingPaths.length > 1)
|
|
remainingPaths.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
|
|
sortedPaths.push(...remainingPaths);
|
|
}
|
|
return sortedPaths;
|
|
}
|
|
function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) {
|
|
var _a2;
|
|
const decl = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(
|
|
(d) => isNonGlobalAmbientModule(d) && (!isExternalModuleAugmentation(d) || !isExternalModuleNameRelative(getTextOfIdentifierOrLiteral(d.name)))
|
|
);
|
|
if (decl) {
|
|
return decl.name.text;
|
|
}
|
|
const ambientModuleDeclareCandidates = mapDefined(
|
|
moduleSymbol.declarations,
|
|
(d) => {
|
|
var _a3, _b, _c, _d;
|
|
if (!isModuleDeclaration(d))
|
|
return;
|
|
const topNamespace = getTopNamespace(d);
|
|
if (!(((_a3 = topNamespace == null ? void 0 : topNamespace.parent) == null ? void 0 : _a3.parent) && isModuleBlock(topNamespace.parent) && isAmbientModule(topNamespace.parent.parent) && isSourceFile(topNamespace.parent.parent.parent)))
|
|
return;
|
|
const exportAssignment = (_d = (_c = (_b = topNamespace.parent.parent.symbol.exports) == null ? void 0 : _b.get("export=")) == null ? void 0 : _c.valueDeclaration) == null ? void 0 : _d.expression;
|
|
if (!exportAssignment)
|
|
return;
|
|
const exportSymbol = checker.getSymbolAtLocation(exportAssignment);
|
|
if (!exportSymbol)
|
|
return;
|
|
const originalExportSymbol = (exportSymbol == null ? void 0 : exportSymbol.flags) & 2097152 /* Alias */ ? checker.getAliasedSymbol(exportSymbol) : exportSymbol;
|
|
if (originalExportSymbol === d.symbol)
|
|
return topNamespace.parent.parent;
|
|
function getTopNamespace(namespaceDeclaration) {
|
|
while (namespaceDeclaration.flags & 4 /* NestedNamespace */) {
|
|
namespaceDeclaration = namespaceDeclaration.parent;
|
|
}
|
|
return namespaceDeclaration;
|
|
}
|
|
}
|
|
);
|
|
const ambientModuleDeclare = ambientModuleDeclareCandidates[0];
|
|
if (ambientModuleDeclare) {
|
|
return ambientModuleDeclare.name.text;
|
|
}
|
|
}
|
|
function getAllowedEndings(preferredEnding, compilerOptions, importMode) {
|
|
if (getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && importMode === 99 /* ESNext */) {
|
|
return [2 /* JsExtension */];
|
|
}
|
|
switch (preferredEnding) {
|
|
case 2 /* JsExtension */:
|
|
return [2 /* JsExtension */, 0 /* Minimal */, 1 /* Index */];
|
|
case 1 /* Index */:
|
|
return [1 /* Index */, 0 /* Minimal */, 2 /* JsExtension */];
|
|
case 0 /* Minimal */:
|
|
return [0 /* Minimal */, 1 /* Index */, 2 /* JsExtension */];
|
|
default:
|
|
Debug.assertNever(preferredEnding);
|
|
}
|
|
}
|
|
function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
|
|
for (const key in paths) {
|
|
for (const patternText2 of paths[key]) {
|
|
const pattern = normalizePath(patternText2);
|
|
const indexOfStar = pattern.indexOf("*");
|
|
const candidates = allowedEndings.map((ending) => ({
|
|
ending,
|
|
value: removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions)
|
|
}));
|
|
if (tryGetExtensionFromPath2(pattern)) {
|
|
candidates.push({ ending: void 0, value: relativeToBaseUrl });
|
|
}
|
|
if (indexOfStar !== -1) {
|
|
const prefix = pattern.substring(0, indexOfStar);
|
|
const suffix = pattern.substring(indexOfStar + 1);
|
|
for (const { ending, value } of candidates) {
|
|
if (value.length >= prefix.length + suffix.length && startsWith(value, prefix) && endsWith(value, suffix) && validateEnding({ ending, value })) {
|
|
const matchedStar = value.substring(prefix.length, value.length - suffix.length);
|
|
return key.replace("*", matchedStar);
|
|
}
|
|
}
|
|
} else if (some(candidates, (c) => c.ending !== 0 /* Minimal */ && pattern === c.value) || some(candidates, (c) => c.ending === 0 /* Minimal */ && pattern === c.value && validateEnding(c))) {
|
|
return key;
|
|
}
|
|
}
|
|
}
|
|
function validateEnding({ ending, value }) {
|
|
return ending !== 0 /* Minimal */ || value === removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions, host);
|
|
}
|
|
}
|
|
function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports, conditions, mode = 0 /* Exact */) {
|
|
if (typeof exports === "string") {
|
|
const pathOrPattern = getNormalizedAbsolutePath(combinePaths(packageDirectory, exports), void 0);
|
|
const extensionSwappedTarget = hasTSFileExtension(targetFilePath) ? removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : void 0;
|
|
switch (mode) {
|
|
case 0 /* Exact */:
|
|
if (comparePaths(targetFilePath, pathOrPattern) === 0 /* EqualTo */ || extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern) === 0 /* EqualTo */) {
|
|
return { moduleFileToTry: packageName };
|
|
}
|
|
break;
|
|
case 1 /* Directory */:
|
|
if (containsPath(pathOrPattern, targetFilePath)) {
|
|
const fragment = getRelativePathFromDirectory(pathOrPattern, targetFilePath, false);
|
|
return { moduleFileToTry: getNormalizedAbsolutePath(combinePaths(combinePaths(packageName, exports), fragment), void 0) };
|
|
}
|
|
break;
|
|
case 2 /* Pattern */:
|
|
const starPos = pathOrPattern.indexOf("*");
|
|
const leadingSlice = pathOrPattern.slice(0, starPos);
|
|
const trailingSlice = pathOrPattern.slice(starPos + 1);
|
|
if (startsWith(targetFilePath, leadingSlice) && endsWith(targetFilePath, trailingSlice)) {
|
|
const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
|
|
return { moduleFileToTry: packageName.replace("*", starReplacement) };
|
|
}
|
|
if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice) && endsWith(extensionSwappedTarget, trailingSlice)) {
|
|
const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
|
|
return { moduleFileToTry: packageName.replace("*", starReplacement) };
|
|
}
|
|
break;
|
|
}
|
|
} else if (Array.isArray(exports)) {
|
|
return forEach(exports, (e) => tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions));
|
|
} else if (typeof exports === "object" && exports !== null) {
|
|
if (allKeysStartWithDot(exports)) {
|
|
return forEach(getOwnKeys(exports), (k) => {
|
|
const subPackageName = getNormalizedAbsolutePath(combinePaths(packageName, k), void 0);
|
|
const mode2 = endsWith(k, "/") ? 1 /* Directory */ : stringContains(k, "*") ? 2 /* Pattern */ : 0 /* Exact */;
|
|
return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports[k], conditions, mode2);
|
|
});
|
|
} else {
|
|
for (const key of getOwnKeys(exports)) {
|
|
if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
|
|
const subTarget = exports[key];
|
|
const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
|
|
const normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
|
|
if (normalizedTargetPaths === void 0) {
|
|
return void 0;
|
|
}
|
|
const normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
|
|
const relativePaths = flatMap(normalizedSourcePaths, (sourcePath) => {
|
|
return map(normalizedTargetPaths, (targetPath) => ensurePathIsNonModuleName(getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)));
|
|
});
|
|
const shortest = min(relativePaths, compareNumberOfDirectorySeparators);
|
|
if (!shortest) {
|
|
return void 0;
|
|
}
|
|
return getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */ ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions) : removeFileExtension(shortest);
|
|
}
|
|
function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileName, sourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
|
|
if (!host.fileExists || !host.readFile) {
|
|
return void 0;
|
|
}
|
|
const parts = getNodeModulePathParts(path);
|
|
if (!parts) {
|
|
return void 0;
|
|
}
|
|
const preferences = getPreferences(host, userPreferences, options, importingSourceFile);
|
|
let moduleSpecifier = path;
|
|
let isPackageRootPath = false;
|
|
if (!packageNameOnly) {
|
|
let packageRootIndex = parts.packageRootIndex;
|
|
let moduleFileName;
|
|
while (true) {
|
|
const { moduleFileToTry, packageRootPath, blockedByExports, verbatimFromExports } = tryDirectoryWithPackageJson(packageRootIndex);
|
|
if (getEmitModuleResolutionKind(options) !== 1 /* Classic */) {
|
|
if (blockedByExports) {
|
|
return void 0;
|
|
}
|
|
if (verbatimFromExports) {
|
|
return moduleFileToTry;
|
|
}
|
|
}
|
|
if (packageRootPath) {
|
|
moduleSpecifier = packageRootPath;
|
|
isPackageRootPath = true;
|
|
break;
|
|
}
|
|
if (!moduleFileName)
|
|
moduleFileName = moduleFileToTry;
|
|
packageRootIndex = path.indexOf(directorySeparator, packageRootIndex + 1);
|
|
if (packageRootIndex === -1) {
|
|
moduleSpecifier = removeExtensionAndIndexPostFix(moduleFileName, preferences.ending, options, host);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (isRedirect && !isPackageRootPath) {
|
|
return void 0;
|
|
}
|
|
const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation();
|
|
const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex));
|
|
if (!(startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
|
|
return void 0;
|
|
}
|
|
const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
|
|
const packageName = getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
|
|
return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageName === nodeModulesDirectoryName ? void 0 : packageName;
|
|
function tryDirectoryWithPackageJson(packageRootIndex) {
|
|
var _a2, _b;
|
|
const packageRootPath = path.substring(0, packageRootIndex);
|
|
const packageJsonPath = combinePaths(packageRootPath, "package.json");
|
|
let moduleFileToTry = path;
|
|
let maybeBlockedByTypesVersions = false;
|
|
const cachedPackageJson = (_b = (_a2 = host.getPackageJsonInfoCache) == null ? void 0 : _a2.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
|
|
if (typeof cachedPackageJson === "object" || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
|
|
const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
|
|
const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
|
|
if (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */) {
|
|
const conditions = ["node", importMode === 99 /* ESNext */ ? "import" : "require", "types"];
|
|
const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions) : void 0;
|
|
if (fromExports) {
|
|
const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
|
|
return { ...withJsExtension, verbatimFromExports: true };
|
|
}
|
|
if (packageJsonContent.exports) {
|
|
return { moduleFileToTry: path, blockedByExports: true };
|
|
}
|
|
}
|
|
const versionPaths = packageJsonContent.typesVersions ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
|
|
if (versionPaths) {
|
|
const subModuleName = path.slice(packageRootPath.length + 1);
|
|
const fromPaths = tryGetModuleNameFromPaths(
|
|
subModuleName,
|
|
versionPaths.paths,
|
|
getAllowedEndings(preferences.ending, options, importMode),
|
|
host,
|
|
options
|
|
);
|
|
if (fromPaths === void 0) {
|
|
maybeBlockedByTypesVersions = true;
|
|
} else {
|
|
moduleFileToTry = combinePaths(packageRootPath, fromPaths);
|
|
}
|
|
}
|
|
const mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
|
|
if (isString(mainFileRelative) && !(maybeBlockedByTypesVersions && matchPatternOrExact(tryParsePatterns(versionPaths.paths), mainFileRelative))) {
|
|
const mainExportFile = toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
|
|
if (removeFileExtension(mainExportFile) === removeFileExtension(getCanonicalFileName(moduleFileToTry))) {
|
|
return { packageRootPath, moduleFileToTry };
|
|
}
|
|
}
|
|
} else {
|
|
const fileName = getCanonicalFileName(moduleFileToTry.substring(parts.packageRootIndex + 1));
|
|
if (fileName === "index.d.ts" || fileName === "index.js" || fileName === "index.ts" || fileName === "index.tsx") {
|
|
return { moduleFileToTry, packageRootPath };
|
|
}
|
|
}
|
|
return { moduleFileToTry };
|
|
}
|
|
}
|
|
function tryGetAnyFileFromPath(host, path) {
|
|
if (!host.fileExists)
|
|
return;
|
|
const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 /* JSON */ }]));
|
|
for (const e of extensions) {
|
|
const fullPath = path + e;
|
|
if (host.fileExists(fullPath)) {
|
|
return fullPath;
|
|
}
|
|
}
|
|
}
|
|
function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
|
|
return mapDefined(rootDirs, (rootDir) => {
|
|
const relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
|
|
return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
|
|
});
|
|
}
|
|
function removeExtensionAndIndexPostFix(fileName, ending, options, host) {
|
|
if (fileExtensionIsOneOf(fileName, [".json" /* Json */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]))
|
|
return fileName;
|
|
const noExtension = removeFileExtension(fileName);
|
|
if (fileName === noExtension)
|
|
return fileName;
|
|
if (fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".d.cts" /* Dcts */, ".cts" /* Cts */]))
|
|
return noExtension + getJSExtensionForFile(fileName, options);
|
|
switch (ending) {
|
|
case 0 /* Minimal */:
|
|
const withoutIndex = removeSuffix(noExtension, "/index");
|
|
if (host && withoutIndex !== noExtension && tryGetAnyFileFromPath(host, withoutIndex)) {
|
|
return noExtension;
|
|
}
|
|
return withoutIndex;
|
|
case 1 /* Index */:
|
|
return noExtension;
|
|
case 2 /* JsExtension */:
|
|
return noExtension + getJSExtensionForFile(fileName, options);
|
|
default:
|
|
return Debug.assertNever(ending);
|
|
}
|
|
}
|
|
function getJSExtensionForFile(fileName, options) {
|
|
var _a2;
|
|
return (_a2 = tryGetJSExtensionForFile(fileName, options)) != null ? _a2 : Debug.fail(`Extension ${extensionFromPath(fileName)} is unsupported:: FileName:: ${fileName}`);
|
|
}
|
|
function tryGetJSExtensionForFile(fileName, options) {
|
|
const ext = tryGetExtensionFromPath2(fileName);
|
|
switch (ext) {
|
|
case ".ts" /* Ts */:
|
|
case ".d.ts" /* Dts */:
|
|
return ".js" /* Js */;
|
|
case ".tsx" /* Tsx */:
|
|
return options.jsx === 1 /* Preserve */ ? ".jsx" /* Jsx */ : ".js" /* Js */;
|
|
case ".js" /* Js */:
|
|
case ".jsx" /* Jsx */:
|
|
case ".json" /* Json */:
|
|
return ext;
|
|
case ".d.mts" /* Dmts */:
|
|
case ".mts" /* Mts */:
|
|
case ".mjs" /* Mjs */:
|
|
return ".mjs" /* Mjs */;
|
|
case ".d.cts" /* Dcts */:
|
|
case ".cts" /* Cts */:
|
|
case ".cjs" /* Cjs */:
|
|
return ".cjs" /* Cjs */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getRelativePathIfInDirectory(path, directoryPath, getCanonicalFileName) {
|
|
const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false);
|
|
return isRootedDiskPath(relativePath) ? void 0 : relativePath;
|
|
}
|
|
function isPathRelativeToParent(path) {
|
|
return startsWith(path, "..");
|
|
}
|
|
|
|
// src/compiler/checker.ts
|
|
var ambientModuleSymbolRegex = /^".+"$/;
|
|
var anon = "(anonymous)";
|
|
var nextSymbolId = 1;
|
|
var nextNodeId = 1;
|
|
var nextMergeId = 1;
|
|
var nextFlowId = 1;
|
|
var TypeFacts = /* @__PURE__ */ ((TypeFacts3) => {
|
|
TypeFacts3[TypeFacts3["None"] = 0] = "None";
|
|
TypeFacts3[TypeFacts3["TypeofEQString"] = 1] = "TypeofEQString";
|
|
TypeFacts3[TypeFacts3["TypeofEQNumber"] = 2] = "TypeofEQNumber";
|
|
TypeFacts3[TypeFacts3["TypeofEQBigInt"] = 4] = "TypeofEQBigInt";
|
|
TypeFacts3[TypeFacts3["TypeofEQBoolean"] = 8] = "TypeofEQBoolean";
|
|
TypeFacts3[TypeFacts3["TypeofEQSymbol"] = 16] = "TypeofEQSymbol";
|
|
TypeFacts3[TypeFacts3["TypeofEQObject"] = 32] = "TypeofEQObject";
|
|
TypeFacts3[TypeFacts3["TypeofEQFunction"] = 64] = "TypeofEQFunction";
|
|
TypeFacts3[TypeFacts3["TypeofEQHostObject"] = 128] = "TypeofEQHostObject";
|
|
TypeFacts3[TypeFacts3["TypeofNEString"] = 256] = "TypeofNEString";
|
|
TypeFacts3[TypeFacts3["TypeofNENumber"] = 512] = "TypeofNENumber";
|
|
TypeFacts3[TypeFacts3["TypeofNEBigInt"] = 1024] = "TypeofNEBigInt";
|
|
TypeFacts3[TypeFacts3["TypeofNEBoolean"] = 2048] = "TypeofNEBoolean";
|
|
TypeFacts3[TypeFacts3["TypeofNESymbol"] = 4096] = "TypeofNESymbol";
|
|
TypeFacts3[TypeFacts3["TypeofNEObject"] = 8192] = "TypeofNEObject";
|
|
TypeFacts3[TypeFacts3["TypeofNEFunction"] = 16384] = "TypeofNEFunction";
|
|
TypeFacts3[TypeFacts3["TypeofNEHostObject"] = 32768] = "TypeofNEHostObject";
|
|
TypeFacts3[TypeFacts3["EQUndefined"] = 65536] = "EQUndefined";
|
|
TypeFacts3[TypeFacts3["EQNull"] = 131072] = "EQNull";
|
|
TypeFacts3[TypeFacts3["EQUndefinedOrNull"] = 262144] = "EQUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["NEUndefined"] = 524288] = "NEUndefined";
|
|
TypeFacts3[TypeFacts3["NENull"] = 1048576] = "NENull";
|
|
TypeFacts3[TypeFacts3["NEUndefinedOrNull"] = 2097152] = "NEUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["Truthy"] = 4194304] = "Truthy";
|
|
TypeFacts3[TypeFacts3["Falsy"] = 8388608] = "Falsy";
|
|
TypeFacts3[TypeFacts3["IsUndefined"] = 16777216] = "IsUndefined";
|
|
TypeFacts3[TypeFacts3["IsNull"] = 33554432] = "IsNull";
|
|
TypeFacts3[TypeFacts3["IsUndefinedOrNull"] = 50331648] = "IsUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["All"] = 134217727] = "All";
|
|
TypeFacts3[TypeFacts3["BaseStringStrictFacts"] = 3735041] = "BaseStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseStringFacts"] = 12582401] = "BaseStringFacts";
|
|
TypeFacts3[TypeFacts3["StringStrictFacts"] = 16317953] = "StringStrictFacts";
|
|
TypeFacts3[TypeFacts3["StringFacts"] = 16776705] = "StringFacts";
|
|
TypeFacts3[TypeFacts3["EmptyStringStrictFacts"] = 12123649] = "EmptyStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["EmptyStringFacts"] = 12582401 /* BaseStringFacts */] = "EmptyStringFacts";
|
|
TypeFacts3[TypeFacts3["NonEmptyStringStrictFacts"] = 7929345] = "NonEmptyStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonEmptyStringFacts"] = 16776705] = "NonEmptyStringFacts";
|
|
TypeFacts3[TypeFacts3["BaseNumberStrictFacts"] = 3734786] = "BaseNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseNumberFacts"] = 12582146] = "BaseNumberFacts";
|
|
TypeFacts3[TypeFacts3["NumberStrictFacts"] = 16317698] = "NumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["NumberFacts"] = 16776450] = "NumberFacts";
|
|
TypeFacts3[TypeFacts3["ZeroNumberStrictFacts"] = 12123394] = "ZeroNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["ZeroNumberFacts"] = 12582146 /* BaseNumberFacts */] = "ZeroNumberFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroNumberStrictFacts"] = 7929090] = "NonZeroNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroNumberFacts"] = 16776450] = "NonZeroNumberFacts";
|
|
TypeFacts3[TypeFacts3["BaseBigIntStrictFacts"] = 3734276] = "BaseBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseBigIntFacts"] = 12581636] = "BaseBigIntFacts";
|
|
TypeFacts3[TypeFacts3["BigIntStrictFacts"] = 16317188] = "BigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["BigIntFacts"] = 16775940] = "BigIntFacts";
|
|
TypeFacts3[TypeFacts3["ZeroBigIntStrictFacts"] = 12122884] = "ZeroBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["ZeroBigIntFacts"] = 12581636 /* BaseBigIntFacts */] = "ZeroBigIntFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroBigIntStrictFacts"] = 7928580] = "NonZeroBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroBigIntFacts"] = 16775940] = "NonZeroBigIntFacts";
|
|
TypeFacts3[TypeFacts3["BaseBooleanStrictFacts"] = 3733256] = "BaseBooleanStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseBooleanFacts"] = 12580616] = "BaseBooleanFacts";
|
|
TypeFacts3[TypeFacts3["BooleanStrictFacts"] = 16316168] = "BooleanStrictFacts";
|
|
TypeFacts3[TypeFacts3["BooleanFacts"] = 16774920] = "BooleanFacts";
|
|
TypeFacts3[TypeFacts3["FalseStrictFacts"] = 12121864] = "FalseStrictFacts";
|
|
TypeFacts3[TypeFacts3["FalseFacts"] = 12580616 /* BaseBooleanFacts */] = "FalseFacts";
|
|
TypeFacts3[TypeFacts3["TrueStrictFacts"] = 7927560] = "TrueStrictFacts";
|
|
TypeFacts3[TypeFacts3["TrueFacts"] = 16774920] = "TrueFacts";
|
|
TypeFacts3[TypeFacts3["SymbolStrictFacts"] = 7925520] = "SymbolStrictFacts";
|
|
TypeFacts3[TypeFacts3["SymbolFacts"] = 16772880] = "SymbolFacts";
|
|
TypeFacts3[TypeFacts3["ObjectStrictFacts"] = 7888800] = "ObjectStrictFacts";
|
|
TypeFacts3[TypeFacts3["ObjectFacts"] = 16736160] = "ObjectFacts";
|
|
TypeFacts3[TypeFacts3["FunctionStrictFacts"] = 7880640] = "FunctionStrictFacts";
|
|
TypeFacts3[TypeFacts3["FunctionFacts"] = 16728e3] = "FunctionFacts";
|
|
TypeFacts3[TypeFacts3["VoidFacts"] = 9830144] = "VoidFacts";
|
|
TypeFacts3[TypeFacts3["UndefinedFacts"] = 26607360] = "UndefinedFacts";
|
|
TypeFacts3[TypeFacts3["NullFacts"] = 42917664] = "NullFacts";
|
|
TypeFacts3[TypeFacts3["EmptyObjectStrictFacts"] = 83427327] = "EmptyObjectStrictFacts";
|
|
TypeFacts3[TypeFacts3["EmptyObjectFacts"] = 83886079] = "EmptyObjectFacts";
|
|
TypeFacts3[TypeFacts3["UnknownFacts"] = 83886079] = "UnknownFacts";
|
|
TypeFacts3[TypeFacts3["AllTypeofNE"] = 556800] = "AllTypeofNE";
|
|
TypeFacts3[TypeFacts3["OrFactsMask"] = 8256] = "OrFactsMask";
|
|
TypeFacts3[TypeFacts3["AndFactsMask"] = 134209471] = "AndFactsMask";
|
|
return TypeFacts3;
|
|
})(TypeFacts || {});
|
|
var typeofNEFacts = new Map(getEntries({
|
|
string: 256 /* TypeofNEString */,
|
|
number: 512 /* TypeofNENumber */,
|
|
bigint: 1024 /* TypeofNEBigInt */,
|
|
boolean: 2048 /* TypeofNEBoolean */,
|
|
symbol: 4096 /* TypeofNESymbol */,
|
|
undefined: 524288 /* NEUndefined */,
|
|
object: 8192 /* TypeofNEObject */,
|
|
function: 16384 /* TypeofNEFunction */
|
|
}));
|
|
var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
|
|
CheckMode3[CheckMode3["Normal"] = 0] = "Normal";
|
|
CheckMode3[CheckMode3["Contextual"] = 1] = "Contextual";
|
|
CheckMode3[CheckMode3["Inferential"] = 2] = "Inferential";
|
|
CheckMode3[CheckMode3["SkipContextSensitive"] = 4] = "SkipContextSensitive";
|
|
CheckMode3[CheckMode3["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
|
|
CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
|
|
CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
|
|
CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
|
|
return CheckMode3;
|
|
})(CheckMode || {});
|
|
var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
|
|
SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
|
|
SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
|
|
SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
|
|
SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
|
|
SignatureCheckMode3[SignatureCheckMode3["StrictArity"] = 8] = "StrictArity";
|
|
SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
|
|
return SignatureCheckMode3;
|
|
})(SignatureCheckMode || {});
|
|
var isNotOverloadAndNotAccessor = and(isNotOverload, isNotAccessor);
|
|
var intrinsicTypeKinds = new Map(getEntries({
|
|
Uppercase: 0 /* Uppercase */,
|
|
Lowercase: 1 /* Lowercase */,
|
|
Capitalize: 2 /* Capitalize */,
|
|
Uncapitalize: 3 /* Uncapitalize */
|
|
}));
|
|
function SymbolLinks() {
|
|
}
|
|
function NodeLinks() {
|
|
this.flags = 0 /* None */;
|
|
}
|
|
function getNodeId(node) {
|
|
if (!node.id) {
|
|
node.id = nextNodeId;
|
|
nextNodeId++;
|
|
}
|
|
return node.id;
|
|
}
|
|
function getSymbolId(symbol) {
|
|
if (!symbol.id) {
|
|
symbol.id = nextSymbolId;
|
|
nextSymbolId++;
|
|
}
|
|
return symbol.id;
|
|
}
|
|
function isInstantiatedModule(node, preserveConstEnums) {
|
|
const moduleState = getModuleInstanceState(node);
|
|
return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
|
|
}
|
|
function createTypeChecker(host) {
|
|
const getPackagesMap = memoize(() => {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
host.getSourceFiles().forEach((sf) => {
|
|
if (!sf.resolvedModules)
|
|
return;
|
|
sf.resolvedModules.forEach((r) => {
|
|
if (r && r.packageId)
|
|
map2.set(r.packageId.name, r.extension === ".d.ts" /* Dts */ || !!map2.get(r.packageId.name));
|
|
});
|
|
});
|
|
return map2;
|
|
});
|
|
let deferredDiagnosticsCallbacks = [];
|
|
let addLazyDiagnostic = (arg) => {
|
|
deferredDiagnosticsCallbacks.push(arg);
|
|
};
|
|
let cancellationToken;
|
|
let requestedExternalEmitHelpers;
|
|
let externalHelpersModule;
|
|
const Symbol12 = objectAllocator.getSymbolConstructor();
|
|
const Type7 = objectAllocator.getTypeConstructor();
|
|
const Signature5 = objectAllocator.getSignatureConstructor();
|
|
let typeCount = 0;
|
|
let symbolCount = 0;
|
|
let totalInstantiationCount = 0;
|
|
let instantiationCount = 0;
|
|
let instantiationDepth = 0;
|
|
let inlineLevel = 0;
|
|
let currentNode;
|
|
let varianceTypeParameter;
|
|
const emptySymbols = createSymbolTable();
|
|
const arrayVariances = [1 /* Covariant */];
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
|
|
const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
|
|
const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
|
|
const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
|
|
const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
|
|
const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
|
|
const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
|
|
const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
|
|
const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
|
|
const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
|
|
const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
|
|
const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
|
|
const checkBinaryExpression = createCheckBinaryExpression();
|
|
const emitResolver = createResolver();
|
|
const nodeBuilder = createNodeBuilder();
|
|
const globals = createSymbolTable();
|
|
const undefinedSymbol = createSymbol(4 /* Property */, "undefined");
|
|
undefinedSymbol.declarations = [];
|
|
const globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
|
|
globalThisSymbol.exports = globals;
|
|
globalThisSymbol.declarations = [];
|
|
globals.set(globalThisSymbol.escapedName, globalThisSymbol);
|
|
const argumentsSymbol = createSymbol(4 /* Property */, "arguments");
|
|
const requireSymbol = createSymbol(4 /* Property */, "require");
|
|
let apparentArgumentCount;
|
|
const checker = {
|
|
getNodeCount: () => sum(host.getSourceFiles(), "nodeCount"),
|
|
getIdentifierCount: () => sum(host.getSourceFiles(), "identifierCount"),
|
|
getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount") + symbolCount,
|
|
getTypeCount: () => typeCount,
|
|
getInstantiationCount: () => totalInstantiationCount,
|
|
getRelationCacheSizes: () => ({
|
|
assignable: assignableRelation.size,
|
|
identity: identityRelation.size,
|
|
subtype: subtypeRelation.size,
|
|
strictSubtype: strictSubtypeRelation.size
|
|
}),
|
|
isUndefinedSymbol: (symbol) => symbol === undefinedSymbol,
|
|
isArgumentsSymbol: (symbol) => symbol === argumentsSymbol,
|
|
isUnknownSymbol: (symbol) => symbol === unknownSymbol,
|
|
getMergedSymbol,
|
|
getDiagnostics,
|
|
getGlobalDiagnostics,
|
|
getRecursionIdentity,
|
|
getUnmatchedProperties,
|
|
getTypeOfSymbolAtLocation: (symbol, locationIn) => {
|
|
const location = getParseTreeNode(locationIn);
|
|
return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType;
|
|
},
|
|
getTypeOfSymbol,
|
|
getSymbolsOfParameterPropertyDeclaration: (parameterIn, parameterName) => {
|
|
const parameter = getParseTreeNode(parameterIn, isParameter);
|
|
if (parameter === void 0)
|
|
return Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node.");
|
|
return getSymbolsOfParameterPropertyDeclaration(parameter, escapeLeadingUnderscores(parameterName));
|
|
},
|
|
getDeclaredTypeOfSymbol,
|
|
getPropertiesOfType,
|
|
getPropertyOfType: (type, name) => getPropertyOfType(type, escapeLeadingUnderscores(name)),
|
|
getPrivateIdentifierPropertyOfType: (leftType, name, location) => {
|
|
const node = getParseTreeNode(location);
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
const propName = escapeLeadingUnderscores(name);
|
|
const lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node);
|
|
return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : void 0;
|
|
},
|
|
getTypeOfPropertyOfType: (type, name) => getTypeOfPropertyOfType(type, escapeLeadingUnderscores(name)),
|
|
getIndexInfoOfType: (type, kind) => getIndexInfoOfType(type, kind === 0 /* String */ ? stringType : numberType),
|
|
getIndexInfosOfType,
|
|
getIndexInfosOfIndexSymbol,
|
|
getSignaturesOfType,
|
|
getIndexTypeOfType: (type, kind) => getIndexTypeOfType(type, kind === 0 /* String */ ? stringType : numberType),
|
|
getIndexType: (type) => getIndexType(type),
|
|
getBaseTypes,
|
|
getBaseTypeOfLiteralType,
|
|
getWidenedType,
|
|
getTypeFromTypeNode: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isTypeNode);
|
|
return node ? getTypeFromTypeNode(node) : errorType;
|
|
},
|
|
getParameterType: getTypeAtPosition,
|
|
getParameterIdentifierNameAtPosition,
|
|
getPromisedTypeOfPromise,
|
|
getAwaitedType: (type) => getAwaitedType(type),
|
|
getReturnTypeOfSignature,
|
|
isNullableType,
|
|
getNullableType,
|
|
getNonNullableType,
|
|
getNonOptionalType: removeOptionalTypeMarker,
|
|
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: (locationIn, meaning) => {
|
|
const location = getParseTreeNode(locationIn);
|
|
return location ? getSymbolsInScope(location, meaning) : [];
|
|
},
|
|
getSymbolAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getSymbolAtLocation(node, true) : void 0;
|
|
},
|
|
getIndexInfosAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getIndexInfosAtLocation(node) : void 0;
|
|
},
|
|
getShorthandAssignmentValueSymbol: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getShorthandAssignmentValueSymbol(node) : void 0;
|
|
},
|
|
getExportSpecifierLocalTargetSymbol: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isExportSpecifier);
|
|
return node ? getExportSpecifierLocalTargetSymbol(node) : void 0;
|
|
},
|
|
getExportSymbolOfSymbol(symbol) {
|
|
return getMergedSymbol(symbol.exportSymbol || symbol);
|
|
},
|
|
getTypeAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getTypeOfNode(node) : errorType;
|
|
},
|
|
getTypeOfAssignmentPattern: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isAssignmentPattern);
|
|
return node && getTypeOfAssignmentPattern(node) || errorType;
|
|
},
|
|
getPropertySymbolOfDestructuringAssignment: (locationIn) => {
|
|
const location = getParseTreeNode(locationIn, isIdentifier);
|
|
return location ? getPropertySymbolOfDestructuringAssignment(location) : void 0;
|
|
},
|
|
signatureToString: (signature, enclosingDeclaration, flags, kind) => {
|
|
return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind);
|
|
},
|
|
typeToString: (type, enclosingDeclaration, flags) => {
|
|
return typeToString(type, getParseTreeNode(enclosingDeclaration), flags);
|
|
},
|
|
symbolToString: (symbol, enclosingDeclaration, meaning, flags) => {
|
|
return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags);
|
|
},
|
|
typePredicateToString: (predicate, enclosingDeclaration, flags) => {
|
|
return typePredicateToString(predicate, getParseTreeNode(enclosingDeclaration), flags);
|
|
},
|
|
writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
|
|
return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
|
|
},
|
|
writeType: (type, enclosingDeclaration, flags, writer) => {
|
|
return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
|
|
},
|
|
writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
|
|
return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
|
|
},
|
|
writeTypePredicate: (predicate, enclosingDeclaration, flags, writer) => {
|
|
return typePredicateToString(predicate, getParseTreeNode(enclosingDeclaration), flags, writer);
|
|
},
|
|
getAugmentedPropertiesOfType,
|
|
getRootSymbols,
|
|
getSymbolOfExpando,
|
|
getContextualType: (nodeIn, contextFlags) => {
|
|
const node = getParseTreeNode(nodeIn, isExpression);
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
if (contextFlags & 4 /* Completions */) {
|
|
return runWithInferenceBlockedFromSourceNode(node, () => getContextualType(node, contextFlags));
|
|
}
|
|
return getContextualType(node, contextFlags);
|
|
},
|
|
getContextualTypeForObjectLiteralElement: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isObjectLiteralElementLike);
|
|
return node ? getContextualTypeForObjectLiteralElement(node, void 0) : void 0;
|
|
},
|
|
getContextualTypeForArgumentAtIndex: (nodeIn, argIndex) => {
|
|
const node = getParseTreeNode(nodeIn, isCallLikeExpression);
|
|
return node && getContextualTypeForArgumentAtIndex(node, argIndex);
|
|
},
|
|
getContextualTypeForJsxAttribute: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isJsxAttributeLike);
|
|
return node && getContextualTypeForJsxAttribute(node, void 0);
|
|
},
|
|
isContextSensitive,
|
|
getTypeOfPropertyOfContextualType,
|
|
getFullyQualifiedName,
|
|
getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */),
|
|
getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => getResolvedSignatureWorker(call, candidatesOutArray, void 0, 32 /* IsForStringLiteralArgumentCompletions */, editingArgument),
|
|
getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */),
|
|
getExpandedParameters,
|
|
hasEffectiveRestParameter,
|
|
containsArgumentsReference,
|
|
getConstantValue: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, canHaveConstantValue);
|
|
return node ? getConstantValue2(node) : void 0;
|
|
},
|
|
isValidPropertyAccess: (nodeIn, propertyName) => {
|
|
const node = getParseTreeNode(nodeIn, isPropertyAccessOrQualifiedNameOrImportTypeNode);
|
|
return !!node && isValidPropertyAccess(node, escapeLeadingUnderscores(propertyName));
|
|
},
|
|
isValidPropertyAccessForCompletions: (nodeIn, type, property) => {
|
|
const node = getParseTreeNode(nodeIn, isPropertyAccessExpression);
|
|
return !!node && isValidPropertyAccessForCompletions(node, type, property);
|
|
},
|
|
getSignatureFromDeclaration: (declarationIn) => {
|
|
const declaration = getParseTreeNode(declarationIn, isFunctionLike);
|
|
return declaration ? getSignatureFromDeclaration(declaration) : void 0;
|
|
},
|
|
isImplementationOfOverload: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isFunctionLike);
|
|
return node ? isImplementationOfOverload(node) : void 0;
|
|
},
|
|
getImmediateAliasedSymbol,
|
|
getAliasedSymbol: resolveAlias,
|
|
getEmitResolver,
|
|
getExportsOfModule: getExportsOfModuleAsArray,
|
|
getExportsAndPropertiesOfModule,
|
|
forEachExportAndPropertyOfModule,
|
|
getSymbolWalker: createGetSymbolWalker(
|
|
getRestTypeOfSignature,
|
|
getTypePredicateOfSignature,
|
|
getReturnTypeOfSignature,
|
|
getBaseTypes,
|
|
resolveStructuredTypeMembers,
|
|
getTypeOfSymbol,
|
|
getResolvedSymbol,
|
|
getConstraintOfTypeParameter,
|
|
getFirstIdentifier,
|
|
getTypeArguments
|
|
),
|
|
getAmbientModules,
|
|
getJsxIntrinsicTagNamesAt,
|
|
isOptionalParameter: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isParameter);
|
|
return node ? isOptionalParameter(node) : false;
|
|
},
|
|
tryGetMemberInModuleExports: (name, symbol) => tryGetMemberInModuleExports(escapeLeadingUnderscores(name), symbol),
|
|
tryGetMemberInModuleExportsAndProperties: (name, symbol) => tryGetMemberInModuleExportsAndProperties(escapeLeadingUnderscores(name), symbol),
|
|
tryFindAmbientModule: (moduleName) => tryFindAmbientModule(moduleName, true),
|
|
tryFindAmbientModuleWithoutAugmentations: (moduleName) => {
|
|
return tryFindAmbientModule(moduleName, false);
|
|
},
|
|
getApparentType,
|
|
getUnionType,
|
|
isTypeAssignableTo,
|
|
createAnonymousType,
|
|
createSignature,
|
|
createSymbol,
|
|
createIndexInfo,
|
|
getAnyType: () => anyType,
|
|
getStringType: () => stringType,
|
|
getNumberType: () => numberType,
|
|
createPromiseType,
|
|
createArrayType,
|
|
getElementTypeOfArrayType,
|
|
getBooleanType: () => booleanType,
|
|
getFalseType: (fresh) => fresh ? falseType : regularFalseType,
|
|
getTrueType: (fresh) => fresh ? trueType : regularTrueType,
|
|
getVoidType: () => voidType,
|
|
getUndefinedType: () => undefinedType,
|
|
getNullType: () => nullType,
|
|
getESSymbolType: () => esSymbolType,
|
|
getNeverType: () => neverType,
|
|
getOptionalType: () => optionalType,
|
|
getPromiseType: () => getGlobalPromiseType(false),
|
|
getPromiseLikeType: () => getGlobalPromiseLikeType(false),
|
|
getAsyncIterableType: () => {
|
|
const type = getGlobalAsyncIterableType(false);
|
|
if (type === emptyGenericType)
|
|
return void 0;
|
|
return type;
|
|
},
|
|
isSymbolAccessible,
|
|
isArrayType,
|
|
isTupleType,
|
|
isArrayLikeType,
|
|
isTypeInvalidDueToUnionDiscriminant,
|
|
getExactOptionalProperties,
|
|
getAllPossiblePropertiesOfTypes,
|
|
getSuggestedSymbolForNonexistentProperty,
|
|
getSuggestionForNonexistentProperty,
|
|
getSuggestedSymbolForNonexistentJSXAttribute,
|
|
getSuggestedSymbolForNonexistentSymbol: (location, name, meaning) => getSuggestedSymbolForNonexistentSymbol(location, escapeLeadingUnderscores(name), meaning),
|
|
getSuggestionForNonexistentSymbol: (location, name, meaning) => getSuggestionForNonexistentSymbol(location, escapeLeadingUnderscores(name), meaning),
|
|
getSuggestedSymbolForNonexistentModule,
|
|
getSuggestionForNonexistentExport,
|
|
getSuggestedSymbolForNonexistentClassMember,
|
|
getBaseConstraintOfType,
|
|
getDefaultFromTypeParameter: (type) => type && type.flags & 262144 /* TypeParameter */ ? getDefaultFromTypeParameter(type) : void 0,
|
|
resolveName(name, location, meaning, excludeGlobals) {
|
|
return resolveName(location, escapeLeadingUnderscores(name), meaning, void 0, void 0, false, excludeGlobals);
|
|
},
|
|
getJsxNamespace: (n) => unescapeLeadingUnderscores(getJsxNamespace(n)),
|
|
getJsxFragmentFactory: (n) => {
|
|
const jsxFragmentFactory = getJsxFragmentFactoryEntity(n);
|
|
return jsxFragmentFactory && unescapeLeadingUnderscores(getFirstIdentifier(jsxFragmentFactory).escapedText);
|
|
},
|
|
getAccessibleSymbolChain,
|
|
getTypePredicateOfSignature,
|
|
resolveExternalModuleName: (moduleSpecifierIn) => {
|
|
const moduleSpecifier = getParseTreeNode(moduleSpecifierIn, isExpression);
|
|
return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, true);
|
|
},
|
|
resolveExternalModuleSymbol,
|
|
tryGetThisTypeAt: (nodeIn, includeGlobalThis, container) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node && tryGetThisTypeAt(node, includeGlobalThis, container);
|
|
},
|
|
getTypeArgumentConstraint: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isTypeNode);
|
|
return node && getTypeArgumentConstraint(node);
|
|
},
|
|
getSuggestionDiagnostics: (fileIn, ct) => {
|
|
const file = getParseTreeNode(fileIn, isSourceFile) || Debug.fail("Could not determine parsed source file.");
|
|
if (skipTypeChecking(file, compilerOptions, host)) {
|
|
return emptyArray;
|
|
}
|
|
let diagnostics2;
|
|
try {
|
|
cancellationToken = ct;
|
|
checkSourceFileWithEagerDiagnostics(file);
|
|
Debug.assert(!!(getNodeLinks(file).flags & 1 /* TypeChecked */));
|
|
diagnostics2 = addRange(diagnostics2, suggestionDiagnostics.getDiagnostics(file.fileName));
|
|
checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), (containingNode, kind, diag2) => {
|
|
if (!containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
|
|
(diagnostics2 || (diagnostics2 = [])).push({ ...diag2, category: 2 /* Suggestion */ });
|
|
}
|
|
});
|
|
return diagnostics2 || emptyArray;
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
},
|
|
runWithCancellationToken: (token, callback) => {
|
|
try {
|
|
cancellationToken = token;
|
|
return callback(checker);
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
},
|
|
getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
|
|
isDeclarationVisible,
|
|
isPropertyAccessible,
|
|
getTypeOnlyAliasDeclaration,
|
|
getMemberOverrideModifierStatus,
|
|
isTypeParameterPossiblyReferenced
|
|
};
|
|
function runWithInferenceBlockedFromSourceNode(node, fn) {
|
|
const containingCall = findAncestor(node, isCallLikeExpression);
|
|
const containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
|
|
if (containingCall) {
|
|
let toMarkSkip = node;
|
|
do {
|
|
getNodeLinks(toMarkSkip).skipDirectInference = true;
|
|
toMarkSkip = toMarkSkip.parent;
|
|
} while (toMarkSkip && toMarkSkip !== containingCall);
|
|
getNodeLinks(containingCall).resolvedSignature = void 0;
|
|
}
|
|
const result = fn();
|
|
if (containingCall) {
|
|
let toMarkSkip = node;
|
|
do {
|
|
getNodeLinks(toMarkSkip).skipDirectInference = void 0;
|
|
toMarkSkip = toMarkSkip.parent;
|
|
} while (toMarkSkip && toMarkSkip !== containingCall);
|
|
getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
|
|
}
|
|
return result;
|
|
}
|
|
function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
|
|
const node = getParseTreeNode(nodeIn, isCallLikeExpression);
|
|
apparentArgumentCount = argumentCount;
|
|
const res = !node ? void 0 : editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignature(node, candidatesOutArray, checkMode)) : getResolvedSignature(node, candidatesOutArray, checkMode);
|
|
apparentArgumentCount = void 0;
|
|
return res;
|
|
}
|
|
const tupleTypes = /* @__PURE__ */ new Map();
|
|
const unionTypes = /* @__PURE__ */ new Map();
|
|
const intersectionTypes = /* @__PURE__ */ new Map();
|
|
const stringLiteralTypes = /* @__PURE__ */ new Map();
|
|
const numberLiteralTypes = /* @__PURE__ */ new Map();
|
|
const bigIntLiteralTypes = /* @__PURE__ */ new Map();
|
|
const enumLiteralTypes = /* @__PURE__ */ new Map();
|
|
const indexedAccessTypes = /* @__PURE__ */ new Map();
|
|
const templateLiteralTypes = /* @__PURE__ */ new Map();
|
|
const stringMappingTypes = /* @__PURE__ */ new Map();
|
|
const substitutionTypes = /* @__PURE__ */ new Map();
|
|
const subtypeReductionCache = /* @__PURE__ */ new Map();
|
|
const cachedTypes = /* @__PURE__ */ new Map();
|
|
const evolvingArrayTypes = [];
|
|
const undefinedProperties = /* @__PURE__ */ new Map();
|
|
const markerTypes = /* @__PURE__ */ new Set();
|
|
const unknownSymbol = createSymbol(4 /* Property */, "unknown");
|
|
const resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
|
|
const unresolvedSymbols = /* @__PURE__ */ new Map();
|
|
const errorTypes = /* @__PURE__ */ new Map();
|
|
const anyType = createIntrinsicType(1 /* Any */, "any");
|
|
const autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
|
|
const wildcardType = createIntrinsicType(1 /* Any */, "any");
|
|
const errorType = createIntrinsicType(1 /* Any */, "error");
|
|
const unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
|
|
const nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
|
|
const intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
|
|
const unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
|
|
const nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
|
|
const undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
|
|
const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
|
|
const optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
|
|
const missingType = exactOptionalPropertyTypes ? createIntrinsicType(32768 /* Undefined */, "undefined") : undefinedType;
|
|
const nullType = createIntrinsicType(65536 /* Null */, "null");
|
|
const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
|
|
const stringType = createIntrinsicType(4 /* String */, "string");
|
|
const numberType = createIntrinsicType(8 /* Number */, "number");
|
|
const bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
|
|
const falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
|
|
const regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
|
|
const trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
|
|
const regularTrueType = createIntrinsicType(512 /* 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;
|
|
const booleanType = getUnionType([regularFalseType, regularTrueType]);
|
|
const esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
|
|
const voidType = createIntrinsicType(16384 /* Void */, "void");
|
|
const neverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
|
|
const implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
|
|
const stringOrNumberType = getUnionType([stringType, numberType]);
|
|
const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
|
|
const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
|
|
const numberOrBigIntType = getUnionType([numberType, bigintType]);
|
|
const templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
|
|
const numericStringType = getTemplateLiteralType(["", ""], [numberType]);
|
|
const restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
|
|
const permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
|
|
const uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
|
|
const uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
|
|
let outofbandVarianceMarkerHandler;
|
|
const reportUnreliableMapper = makeFunctionTypeMapper((t) => {
|
|
if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
|
|
outofbandVarianceMarkerHandler(true);
|
|
}
|
|
return t;
|
|
}, () => "(unmeasurable reporter)");
|
|
const reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
|
|
if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
|
|
outofbandVarianceMarkerHandler(false);
|
|
}
|
|
return t;
|
|
}, () => "(unreliable reporter)");
|
|
const emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
|
|
const emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
emptyTypeLiteralSymbol.members = createSymbolTable();
|
|
const emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
|
|
const emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
emptyGenericType.instantiations = /* @__PURE__ */ new Map();
|
|
const anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
anyFunctionType.objectFlags |= 262144 /* NonInferrableType */;
|
|
const noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const markerSuperType = createTypeParameter();
|
|
const markerSubType = createTypeParameter();
|
|
markerSubType.constraint = markerSuperType;
|
|
const markerOtherType = createTypeParameter();
|
|
const markerSuperTypeForCheck = createTypeParameter();
|
|
const markerSubTypeForCheck = createTypeParameter();
|
|
markerSubTypeForCheck.constraint = markerSuperTypeForCheck;
|
|
const noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
|
|
const anySignature = createSignature(void 0, void 0, void 0, emptyArray, anyType, void 0, 0, 0 /* None */);
|
|
const unknownSignature = createSignature(void 0, void 0, void 0, emptyArray, errorType, void 0, 0, 0 /* None */);
|
|
const resolvingSignature = createSignature(void 0, void 0, void 0, emptyArray, anyType, void 0, 0, 0 /* None */);
|
|
const silentNeverSignature = createSignature(void 0, void 0, void 0, emptyArray, silentNeverType, void 0, 0, 0 /* None */);
|
|
const enumNumberIndexInfo = createIndexInfo(numberType, stringType, true);
|
|
const iterationTypesCache = /* @__PURE__ */ new Map();
|
|
const noIterationTypes = {
|
|
get yieldType() {
|
|
return Debug.fail("Not supported");
|
|
},
|
|
get returnType() {
|
|
return Debug.fail("Not supported");
|
|
},
|
|
get nextType() {
|
|
return Debug.fail("Not supported");
|
|
}
|
|
};
|
|
const anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
|
|
const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
|
|
const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
|
|
const asyncIterationTypesResolver = {
|
|
iterableCacheKey: "iterationTypesOfAsyncIterable",
|
|
iteratorCacheKey: "iterationTypesOfAsyncIterator",
|
|
iteratorSymbolName: "asyncIterator",
|
|
getGlobalIteratorType: getGlobalAsyncIteratorType,
|
|
getGlobalIterableType: getGlobalAsyncIterableType,
|
|
getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
|
|
getGlobalGeneratorType: getGlobalAsyncGeneratorType,
|
|
resolveIterationType: getAwaitedType,
|
|
mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
|
|
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
|
|
mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
|
|
};
|
|
const syncIterationTypesResolver = {
|
|
iterableCacheKey: "iterationTypesOfIterable",
|
|
iteratorCacheKey: "iterationTypesOfIterator",
|
|
iteratorSymbolName: "iterator",
|
|
getGlobalIteratorType,
|
|
getGlobalIterableType,
|
|
getGlobalIterableIteratorType,
|
|
getGlobalGeneratorType,
|
|
resolveIterationType: (type, _errorNode) => type,
|
|
mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
|
|
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
|
|
mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property
|
|
};
|
|
let amalgamatedDuplicates;
|
|
const reverseMappedCache = /* @__PURE__ */ new Map();
|
|
let inInferTypeForHomomorphicMappedType = false;
|
|
let ambientModulesCache;
|
|
let patternAmbientModules;
|
|
let patternAmbientModuleAugmentations;
|
|
let globalObjectType;
|
|
let globalFunctionType;
|
|
let globalCallableFunctionType;
|
|
let globalNewableFunctionType;
|
|
let globalArrayType;
|
|
let globalReadonlyArrayType;
|
|
let globalStringType;
|
|
let globalNumberType;
|
|
let globalBooleanType;
|
|
let globalRegExpType;
|
|
let globalThisType;
|
|
let anyArrayType;
|
|
let autoArrayType;
|
|
let anyReadonlyArrayType;
|
|
let deferredGlobalNonNullableTypeAlias;
|
|
let deferredGlobalESSymbolConstructorSymbol;
|
|
let deferredGlobalESSymbolConstructorTypeSymbol;
|
|
let deferredGlobalESSymbolType;
|
|
let deferredGlobalTypedPropertyDescriptorType;
|
|
let deferredGlobalPromiseType;
|
|
let deferredGlobalPromiseLikeType;
|
|
let deferredGlobalPromiseConstructorSymbol;
|
|
let deferredGlobalPromiseConstructorLikeType;
|
|
let deferredGlobalIterableType;
|
|
let deferredGlobalIteratorType;
|
|
let deferredGlobalIterableIteratorType;
|
|
let deferredGlobalGeneratorType;
|
|
let deferredGlobalIteratorYieldResultType;
|
|
let deferredGlobalIteratorReturnResultType;
|
|
let deferredGlobalAsyncIterableType;
|
|
let deferredGlobalAsyncIteratorType;
|
|
let deferredGlobalAsyncIterableIteratorType;
|
|
let deferredGlobalAsyncGeneratorType;
|
|
let deferredGlobalTemplateStringsArrayType;
|
|
let deferredGlobalImportMetaType;
|
|
let deferredGlobalImportMetaExpressionType;
|
|
let deferredGlobalImportCallOptionsType;
|
|
let deferredGlobalExtractSymbol;
|
|
let deferredGlobalOmitSymbol;
|
|
let deferredGlobalAwaitedSymbol;
|
|
let deferredGlobalBigIntType;
|
|
let deferredGlobalNaNSymbol;
|
|
let deferredGlobalRecordSymbol;
|
|
const allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
|
|
let flowLoopStart = 0;
|
|
let flowLoopCount = 0;
|
|
let sharedFlowCount = 0;
|
|
let flowAnalysisDisabled = false;
|
|
let flowInvocationCount = 0;
|
|
let lastFlowNode;
|
|
let lastFlowNodeReachable;
|
|
let flowTypeCache;
|
|
const emptyStringType = getStringLiteralType("");
|
|
const zeroType = getNumberLiteralType(0);
|
|
const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
|
|
const resolutionTargets = [];
|
|
const resolutionResults = [];
|
|
const resolutionPropertyNames = [];
|
|
let suggestionCount = 0;
|
|
const maximumSuggestionCount = 10;
|
|
const mergedSymbols = [];
|
|
const symbolLinks = [];
|
|
const nodeLinks = [];
|
|
const flowLoopCaches = [];
|
|
const flowLoopNodes = [];
|
|
const flowLoopKeys = [];
|
|
const flowLoopTypes = [];
|
|
const sharedFlowNodes = [];
|
|
const sharedFlowTypes = [];
|
|
const flowNodeReachable = [];
|
|
const flowNodePostSuper = [];
|
|
const potentialThisCollisions = [];
|
|
const potentialNewTargetCollisions = [];
|
|
const potentialWeakMapSetCollisions = [];
|
|
const potentialReflectCollisions = [];
|
|
const potentialUnusedRenamedBindingElementsInTypes = [];
|
|
const awaitedTypeStack = [];
|
|
const diagnostics = createDiagnosticCollection();
|
|
const suggestionDiagnostics = createDiagnosticCollection();
|
|
const typeofType = createTypeofType();
|
|
let _jsxNamespace;
|
|
let _jsxFactoryEntity;
|
|
const subtypeRelation = /* @__PURE__ */ new Map();
|
|
const strictSubtypeRelation = /* @__PURE__ */ new Map();
|
|
const assignableRelation = /* @__PURE__ */ new Map();
|
|
const comparableRelation = /* @__PURE__ */ new Map();
|
|
const identityRelation = /* @__PURE__ */ new Map();
|
|
const enumRelation = /* @__PURE__ */ new Map();
|
|
const builtinGlobals = createSymbolTable();
|
|
builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
|
|
const suggestedExtensions = [
|
|
[".mts", ".mjs"],
|
|
[".ts", ".js"],
|
|
[".cts", ".cjs"],
|
|
[".mjs", ".mjs"],
|
|
[".js", ".js"],
|
|
[".cjs", ".cjs"],
|
|
[".tsx", compilerOptions.jsx === 1 /* Preserve */ ? ".jsx" : ".js"],
|
|
[".jsx", ".jsx"],
|
|
[".json", ".json"]
|
|
];
|
|
initializeTypeChecker();
|
|
return checker;
|
|
function getCachedType(key) {
|
|
return key ? cachedTypes.get(key) : void 0;
|
|
}
|
|
function setCachedType(key, type) {
|
|
if (key)
|
|
cachedTypes.set(key, type);
|
|
return type;
|
|
}
|
|
function getJsxNamespace(location) {
|
|
if (location) {
|
|
const file = getSourceFileOfNode(location);
|
|
if (file) {
|
|
if (isJsxOpeningFragment(location)) {
|
|
if (file.localJsxFragmentNamespace) {
|
|
return file.localJsxFragmentNamespace;
|
|
}
|
|
const jsxFragmentPragma = file.pragmas.get("jsxfrag");
|
|
if (jsxFragmentPragma) {
|
|
const chosenPragma = isArray(jsxFragmentPragma) ? jsxFragmentPragma[0] : jsxFragmentPragma;
|
|
file.localJsxFragmentFactory = parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
|
|
visitNode(file.localJsxFragmentFactory, markAsSynthetic);
|
|
if (file.localJsxFragmentFactory) {
|
|
return file.localJsxFragmentNamespace = getFirstIdentifier(file.localJsxFragmentFactory).escapedText;
|
|
}
|
|
}
|
|
const entity = getJsxFragmentFactoryEntity(location);
|
|
if (entity) {
|
|
file.localJsxFragmentFactory = entity;
|
|
return file.localJsxFragmentNamespace = getFirstIdentifier(entity).escapedText;
|
|
}
|
|
} else {
|
|
const localJsxNamespace = getLocalJsxNamespace(file);
|
|
if (localJsxNamespace) {
|
|
return file.localJsxNamespace = localJsxNamespace;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!_jsxNamespace) {
|
|
_jsxNamespace = "React";
|
|
if (compilerOptions.jsxFactory) {
|
|
_jsxFactoryEntity = parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion);
|
|
visitNode(_jsxFactoryEntity, markAsSynthetic);
|
|
if (_jsxFactoryEntity) {
|
|
_jsxNamespace = getFirstIdentifier(_jsxFactoryEntity).escapedText;
|
|
}
|
|
} else if (compilerOptions.reactNamespace) {
|
|
_jsxNamespace = escapeLeadingUnderscores(compilerOptions.reactNamespace);
|
|
}
|
|
}
|
|
if (!_jsxFactoryEntity) {
|
|
_jsxFactoryEntity = factory.createQualifiedName(factory.createIdentifier(unescapeLeadingUnderscores(_jsxNamespace)), "createElement");
|
|
}
|
|
return _jsxNamespace;
|
|
}
|
|
function getLocalJsxNamespace(file) {
|
|
if (file.localJsxNamespace) {
|
|
return file.localJsxNamespace;
|
|
}
|
|
const jsxPragma = file.pragmas.get("jsx");
|
|
if (jsxPragma) {
|
|
const chosenPragma = isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
|
|
file.localJsxFactory = parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
|
|
visitNode(file.localJsxFactory, markAsSynthetic);
|
|
if (file.localJsxFactory) {
|
|
return file.localJsxNamespace = getFirstIdentifier(file.localJsxFactory).escapedText;
|
|
}
|
|
}
|
|
}
|
|
function markAsSynthetic(node) {
|
|
setTextRangePosEnd(node, -1, -1);
|
|
return visitEachChild(node, markAsSynthetic, nullTransformationContext);
|
|
}
|
|
function getEmitResolver(sourceFile, cancellationToken2) {
|
|
getDiagnostics(sourceFile, cancellationToken2);
|
|
return emitResolver;
|
|
}
|
|
function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
|
|
const existing = diagnostics.lookup(diagnostic);
|
|
if (existing) {
|
|
return existing;
|
|
} else {
|
|
diagnostics.add(diagnostic);
|
|
return diagnostic;
|
|
}
|
|
}
|
|
function errorSkippedOn(key, location, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
|
|
diagnostic.skippedOn = key;
|
|
return diagnostic;
|
|
}
|
|
function createError(location, message, arg0, arg1, arg2, arg3) {
|
|
return location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function error(location, message, arg0, arg1, arg2, arg3) {
|
|
const 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({ ...diagnostic, category: 2 /* Suggestion */ });
|
|
}
|
|
}
|
|
function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) {
|
|
if (location.pos < 0 || location.end < 0) {
|
|
if (!isError) {
|
|
return;
|
|
}
|
|
const file = getSourceFileOfNode(location);
|
|
addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message));
|
|
return;
|
|
}
|
|
addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(location, message));
|
|
}
|
|
function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
|
|
if (maybeMissingAwait) {
|
|
const related = createDiagnosticForNode(location, Diagnostics.Did_you_forget_to_use_await);
|
|
addRelatedInfo(diagnostic, related);
|
|
}
|
|
return diagnostic;
|
|
}
|
|
function addDeprecatedSuggestionWorker(declarations, diagnostic) {
|
|
const deprecatedTag = Array.isArray(declarations) ? forEach(declarations, getJSDocDeprecatedTag) : getJSDocDeprecatedTag(declarations);
|
|
if (deprecatedTag) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(deprecatedTag, Diagnostics.The_declaration_was_marked_as_deprecated_here)
|
|
);
|
|
}
|
|
suggestionDiagnostics.add(diagnostic);
|
|
return diagnostic;
|
|
}
|
|
function isDeprecatedSymbol(symbol) {
|
|
return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
|
|
}
|
|
function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
|
|
const diagnostic = createDiagnosticForNode(location, Diagnostics._0_is_deprecated, deprecatedEntity);
|
|
return addDeprecatedSuggestionWorker(declarations, diagnostic);
|
|
}
|
|
function addDeprecatedSuggestionWithSignature(location, declaration, deprecatedEntity, signatureString) {
|
|
const diagnostic = deprecatedEntity ? createDiagnosticForNode(location, Diagnostics.The_signature_0_of_1_is_deprecated, signatureString, deprecatedEntity) : createDiagnosticForNode(location, Diagnostics._0_is_deprecated, signatureString);
|
|
return addDeprecatedSuggestionWorker(declaration, diagnostic);
|
|
}
|
|
function createSymbol(flags, name, checkFlags) {
|
|
symbolCount++;
|
|
const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
|
|
symbol.checkFlags = checkFlags || 0 /* None */;
|
|
return symbol;
|
|
}
|
|
function getExcludedSymbolFlags(flags) {
|
|
let result = 0;
|
|
if (flags & 2 /* BlockScopedVariable */)
|
|
result |= 111551 /* BlockScopedVariableExcludes */;
|
|
if (flags & 1 /* FunctionScopedVariable */)
|
|
result |= 111550 /* FunctionScopedVariableExcludes */;
|
|
if (flags & 4 /* Property */)
|
|
result |= 0 /* PropertyExcludes */;
|
|
if (flags & 8 /* EnumMember */)
|
|
result |= 900095 /* EnumMemberExcludes */;
|
|
if (flags & 16 /* Function */)
|
|
result |= 110991 /* FunctionExcludes */;
|
|
if (flags & 32 /* Class */)
|
|
result |= 899503 /* ClassExcludes */;
|
|
if (flags & 64 /* Interface */)
|
|
result |= 788872 /* InterfaceExcludes */;
|
|
if (flags & 256 /* RegularEnum */)
|
|
result |= 899327 /* RegularEnumExcludes */;
|
|
if (flags & 128 /* ConstEnum */)
|
|
result |= 899967 /* ConstEnumExcludes */;
|
|
if (flags & 512 /* ValueModule */)
|
|
result |= 110735 /* ValueModuleExcludes */;
|
|
if (flags & 8192 /* Method */)
|
|
result |= 103359 /* MethodExcludes */;
|
|
if (flags & 32768 /* GetAccessor */)
|
|
result |= 46015 /* GetAccessorExcludes */;
|
|
if (flags & 65536 /* SetAccessor */)
|
|
result |= 78783 /* SetAccessorExcludes */;
|
|
if (flags & 262144 /* TypeParameter */)
|
|
result |= 526824 /* TypeParameterExcludes */;
|
|
if (flags & 524288 /* TypeAlias */)
|
|
result |= 788968 /* TypeAliasExcludes */;
|
|
if (flags & 2097152 /* Alias */)
|
|
result |= 2097152 /* AliasExcludes */;
|
|
return result;
|
|
}
|
|
function recordMergedSymbol(target, source) {
|
|
if (!source.mergeId) {
|
|
source.mergeId = nextMergeId;
|
|
nextMergeId++;
|
|
}
|
|
mergedSymbols[source.mergeId] = target;
|
|
}
|
|
function cloneSymbol(symbol) {
|
|
const 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 Map(symbol.members);
|
|
if (symbol.exports)
|
|
result.exports = new Map(symbol.exports);
|
|
recordMergedSymbol(result, symbol);
|
|
return result;
|
|
}
|
|
function mergeSymbol(target, source, unidirectional = false) {
|
|
if (!(target.flags & getExcludedSymbolFlags(source.flags)) || (source.flags | target.flags) & 67108864 /* Assignment */) {
|
|
if (source === target) {
|
|
return target;
|
|
}
|
|
if (!(target.flags & 33554432 /* Transient */)) {
|
|
const resolvedTarget = resolveSymbol(target);
|
|
if (resolvedTarget === unknownSymbol) {
|
|
return source;
|
|
}
|
|
target = cloneSymbol(resolvedTarget);
|
|
}
|
|
if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
|
|
target.constEnumOnlyModule = false;
|
|
}
|
|
target.flags |= source.flags;
|
|
if (source.valueDeclaration) {
|
|
setValueDeclaration(target, source.valueDeclaration);
|
|
}
|
|
addRange(target.declarations, source.declarations);
|
|
if (source.members) {
|
|
if (!target.members)
|
|
target.members = createSymbolTable();
|
|
mergeSymbolTable(target.members, source.members, unidirectional);
|
|
}
|
|
if (source.exports) {
|
|
if (!target.exports)
|
|
target.exports = createSymbolTable();
|
|
mergeSymbolTable(target.exports, source.exports, unidirectional);
|
|
}
|
|
if (!unidirectional) {
|
|
recordMergedSymbol(target, source);
|
|
}
|
|
} else if (target.flags & 1024 /* NamespaceModule */) {
|
|
if (target !== globalThisSymbol) {
|
|
error(
|
|
source.declarations && getNameOfDeclaration(source.declarations[0]),
|
|
Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity,
|
|
symbolToString(target)
|
|
);
|
|
}
|
|
} else {
|
|
const isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
|
|
const isEitherBlockScoped = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
|
|
const message = isEitherEnum ? Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations : isEitherBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
const sourceSymbolFile = source.declarations && getSourceFileOfNode(source.declarations[0]);
|
|
const targetSymbolFile = target.declarations && getSourceFileOfNode(target.declarations[0]);
|
|
const isSourcePlainJs = isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
|
|
const isTargetPlainJs = isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
|
|
const symbolName2 = symbolToString(source);
|
|
if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
|
|
const firstFile = comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* LessThan */ ? sourceSymbolFile : targetSymbolFile;
|
|
const secondFile = firstFile === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
|
|
const filesDuplicates = getOrUpdate(amalgamatedDuplicates, `${firstFile.path}|${secondFile.path}`, () => ({ firstFile, secondFile, conflictingSymbols: /* @__PURE__ */ new Map() }));
|
|
const conflictingSymbolInfo = getOrUpdate(filesDuplicates.conflictingSymbols, symbolName2, () => ({ isBlockScoped: isEitherBlockScoped, firstFileLocations: [], secondFileLocations: [] }));
|
|
if (!isSourcePlainJs)
|
|
addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
|
|
if (!isTargetPlainJs)
|
|
addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
|
|
} else {
|
|
if (!isSourcePlainJs)
|
|
addDuplicateDeclarationErrorsForSymbols(source, message, symbolName2, target);
|
|
if (!isTargetPlainJs)
|
|
addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source);
|
|
}
|
|
}
|
|
return target;
|
|
function addDuplicateLocations(locs, symbol) {
|
|
if (symbol.declarations) {
|
|
for (const decl of symbol.declarations) {
|
|
pushIfUnique(locs, decl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source) {
|
|
forEach(target.declarations, (node) => {
|
|
addDuplicateDeclarationError(node, message, symbolName2, source.declarations);
|
|
});
|
|
}
|
|
function addDuplicateDeclarationError(node, message, symbolName2, relatedNodes) {
|
|
const errorNode = (getExpandoInitializer(node, false) ? getNameOfExpando(node) : getNameOfDeclaration(node)) || node;
|
|
const err = lookupOrIssueError(errorNode, message, symbolName2);
|
|
for (const relatedNode of relatedNodes || emptyArray) {
|
|
const adjustedNode = (getExpandoInitializer(relatedNode, false) ? getNameOfExpando(relatedNode) : getNameOfDeclaration(relatedNode)) || relatedNode;
|
|
if (adjustedNode === errorNode)
|
|
continue;
|
|
err.relatedInformation = err.relatedInformation || [];
|
|
const leadingMessage = createDiagnosticForNode(adjustedNode, Diagnostics._0_was_also_declared_here, symbolName2);
|
|
const followOnMessage = createDiagnosticForNode(adjustedNode, Diagnostics.and_here);
|
|
if (length(err.relatedInformation) >= 5 || some(err.relatedInformation, (r) => compareDiagnostics(r, followOnMessage) === 0 /* EqualTo */ || compareDiagnostics(r, leadingMessage) === 0 /* EqualTo */))
|
|
continue;
|
|
addRelatedInfo(err, !length(err.relatedInformation) ? leadingMessage : followOnMessage);
|
|
}
|
|
}
|
|
function combineSymbolTables(first2, second) {
|
|
if (!(first2 == null ? void 0 : first2.size))
|
|
return second;
|
|
if (!(second == null ? void 0 : second.size))
|
|
return first2;
|
|
const combined = createSymbolTable();
|
|
mergeSymbolTable(combined, first2);
|
|
mergeSymbolTable(combined, second);
|
|
return combined;
|
|
}
|
|
function mergeSymbolTable(target, source, unidirectional = false) {
|
|
source.forEach((sourceSymbol, id) => {
|
|
const targetSymbol = target.get(id);
|
|
target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : getMergedSymbol(sourceSymbol));
|
|
});
|
|
}
|
|
function mergeModuleAugmentation(moduleName) {
|
|
var _a2, _b, _c;
|
|
const moduleAugmentation = moduleName.parent;
|
|
if (((_a2 = moduleAugmentation.symbol.declarations) == null ? void 0 : _a2[0]) !== moduleAugmentation) {
|
|
Debug.assert(moduleAugmentation.symbol.declarations.length > 1);
|
|
return;
|
|
}
|
|
if (isGlobalScopeAugmentation(moduleAugmentation)) {
|
|
mergeSymbolTable(globals, moduleAugmentation.symbol.exports);
|
|
} else {
|
|
const moduleNotFoundError = !(moduleName.parent.parent.flags & 16777216 /* Ambient */) ? Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found : void 0;
|
|
let mainModule = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, true);
|
|
if (!mainModule) {
|
|
return;
|
|
}
|
|
mainModule = resolveExternalModuleSymbol(mainModule);
|
|
if (mainModule.flags & 1920 /* Namespace */) {
|
|
if (some(patternAmbientModules, (module2) => mainModule === module2.symbol)) {
|
|
const merged = mergeSymbol(moduleAugmentation.symbol, mainModule, true);
|
|
if (!patternAmbientModuleAugmentations) {
|
|
patternAmbientModuleAugmentations = /* @__PURE__ */ new Map();
|
|
}
|
|
patternAmbientModuleAugmentations.set(moduleName.text, merged);
|
|
} else {
|
|
if (((_b = mainModule.exports) == null ? void 0 : _b.get("__export" /* ExportStar */)) && ((_c = moduleAugmentation.symbol.exports) == null ? void 0 : _c.size)) {
|
|
const resolvedExports = getResolvedMembersOrExportsOfSymbol(mainModule, "resolvedExports" /* resolvedExports */);
|
|
for (const [key, value] of arrayFrom(moduleAugmentation.symbol.exports.entries())) {
|
|
if (resolvedExports.has(key) && !mainModule.exports.has(key)) {
|
|
mergeSymbol(resolvedExports.get(key), value);
|
|
}
|
|
}
|
|
}
|
|
mergeSymbol(mainModule, moduleAugmentation.symbol);
|
|
}
|
|
} else {
|
|
error(moduleName, Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text);
|
|
}
|
|
}
|
|
}
|
|
function addToSymbolTable(target, source, message) {
|
|
source.forEach((sourceSymbol, id) => {
|
|
const targetSymbol = target.get(id);
|
|
if (targetSymbol) {
|
|
forEach(targetSymbol.declarations, addDeclarationDiagnostic(unescapeLeadingUnderscores(id), message));
|
|
} else {
|
|
target.set(id, sourceSymbol);
|
|
}
|
|
});
|
|
function addDeclarationDiagnostic(id, message2) {
|
|
return (declaration) => diagnostics.add(createDiagnosticForNode(declaration, message2, id));
|
|
}
|
|
}
|
|
function getSymbolLinks(symbol) {
|
|
if (symbol.flags & 33554432 /* Transient */)
|
|
return symbol;
|
|
const id = getSymbolId(symbol);
|
|
return symbolLinks[id] || (symbolLinks[id] = new SymbolLinks());
|
|
}
|
|
function getNodeLinks(node) {
|
|
const nodeId = getNodeId(node);
|
|
return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
|
|
}
|
|
function isGlobalSourceFile(node) {
|
|
return node.kind === 308 /* SourceFile */ && !isExternalOrCommonJsModule(node);
|
|
}
|
|
function getSymbol(symbols, name, meaning) {
|
|
if (meaning) {
|
|
const symbol = getMergedSymbol(symbols.get(name));
|
|
if (symbol) {
|
|
Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
|
|
if (symbol.flags & meaning) {
|
|
return symbol;
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
const targetFlags = getAllSymbolFlags(symbol);
|
|
if (targetFlags & meaning) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
|
|
const constructorDeclaration = parameter.parent;
|
|
const classDeclaration = parameter.parent.parent;
|
|
const parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 111551 /* Value */);
|
|
const propertySymbol = getSymbol(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551 /* Value */);
|
|
if (parameterSymbol && propertySymbol) {
|
|
return [parameterSymbol, propertySymbol];
|
|
}
|
|
return Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
|
|
}
|
|
function isBlockScopedNameDeclaredBeforeUse(declaration, usage) {
|
|
const declarationFile = getSourceFileOfNode(declaration);
|
|
const useFile = getSourceFileOfNode(usage);
|
|
const declContainer = getEnclosingBlockScopeContainer(declaration);
|
|
if (declarationFile !== useFile) {
|
|
if (moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator) || !outFile(compilerOptions) || isInTypeQuery(usage) || declaration.flags & 16777216 /* Ambient */) {
|
|
return true;
|
|
}
|
|
if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
|
|
return true;
|
|
}
|
|
const sourceFiles = host.getSourceFiles();
|
|
return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
|
|
}
|
|
if (declaration.pos <= usage.pos && !(isPropertyDeclaration(declaration) && isThisProperty(usage.parent) && !declaration.initializer && !declaration.exclamationToken)) {
|
|
if (declaration.kind === 205 /* BindingElement */) {
|
|
const errorBindingElement = getAncestor(usage, 205 /* BindingElement */);
|
|
if (errorBindingElement) {
|
|
return findAncestor(errorBindingElement, isBindingElement) !== findAncestor(declaration, isBindingElement) || declaration.pos < errorBindingElement.pos;
|
|
}
|
|
return isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, 257 /* VariableDeclaration */), usage);
|
|
} else if (declaration.kind === 257 /* VariableDeclaration */) {
|
|
return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
|
|
} else if (isClassDeclaration(declaration)) {
|
|
return !findAncestor(usage, (n) => isComputedPropertyName(n) && n.parent.parent === declaration);
|
|
} else if (isPropertyDeclaration(declaration)) {
|
|
return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
|
|
} else if (isParameterPropertyDeclaration(declaration, declaration.parent)) {
|
|
return !(getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) === getContainingClass(usage) && isUsedInFunctionOrInstanceProperty(usage, declaration));
|
|
}
|
|
return true;
|
|
}
|
|
if (usage.parent.kind === 278 /* ExportSpecifier */ || usage.parent.kind === 274 /* ExportAssignment */ && usage.parent.isExportEquals) {
|
|
return true;
|
|
}
|
|
if (usage.kind === 274 /* ExportAssignment */ && usage.isExportEquals) {
|
|
return true;
|
|
}
|
|
if (!!(usage.flags & 8388608 /* JSDoc */) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
|
|
return true;
|
|
}
|
|
if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
|
|
if (getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
|
|
return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
function usageInTypeDeclaration() {
|
|
return !!findAncestor(usage, (node) => isInterfaceDeclaration(node) || isTypeAliasDeclaration(node));
|
|
}
|
|
function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration2, usage2) {
|
|
switch (declaration2.parent.parent.kind) {
|
|
case 240 /* VariableStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
if (isSameScopeDescendentOf(usage2, declaration2, declContainer)) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
const grandparent = declaration2.parent.parent;
|
|
return isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage2, grandparent.expression, declContainer);
|
|
}
|
|
function isUsedInFunctionOrInstanceProperty(usage2, declaration2) {
|
|
return !!findAncestor(usage2, (current) => {
|
|
if (current === declContainer) {
|
|
return "quit";
|
|
}
|
|
if (isFunctionLike(current)) {
|
|
return true;
|
|
}
|
|
if (isClassStaticBlockDeclaration(current)) {
|
|
return declaration2.pos < usage2.pos;
|
|
}
|
|
const propertyDeclaration = tryCast(current.parent, isPropertyDeclaration);
|
|
if (propertyDeclaration) {
|
|
const initializerOfProperty = propertyDeclaration.initializer === current;
|
|
if (initializerOfProperty) {
|
|
if (isStatic(current.parent)) {
|
|
if (declaration2.kind === 171 /* MethodDeclaration */) {
|
|
return true;
|
|
}
|
|
if (isPropertyDeclaration(declaration2) && getContainingClass(usage2) === getContainingClass(declaration2)) {
|
|
const propName = declaration2.name;
|
|
if (isIdentifier(propName) || isPrivateIdentifier(propName)) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(declaration2));
|
|
const staticBlocks = filter(declaration2.parent.members, isClassStaticBlockDeclaration);
|
|
if (isPropertyInitializedInStaticBlocks(propName, type, staticBlocks, declaration2.parent.pos, current.pos)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const isDeclarationInstanceProperty = declaration2.kind === 169 /* PropertyDeclaration */ && !isStatic(declaration2);
|
|
if (!isDeclarationInstanceProperty || getContainingClass(usage2) !== getContainingClass(declaration2)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function isPropertyImmediatelyReferencedWithinDeclaration(declaration2, usage2, stopAtAnyPropertyDeclaration) {
|
|
if (usage2.end > declaration2.end) {
|
|
return false;
|
|
}
|
|
const ancestorChangingReferenceScope = findAncestor(usage2, (node) => {
|
|
if (node === declaration2) {
|
|
return "quit";
|
|
}
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
case 169 /* PropertyDeclaration */:
|
|
return stopAtAnyPropertyDeclaration && (isPropertyDeclaration(declaration2) && node.parent === declaration2.parent || isParameterPropertyDeclaration(declaration2, declaration2.parent) && node.parent === declaration2.parent.parent) ? "quit" : true;
|
|
case 238 /* Block */:
|
|
switch (node.parent.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
});
|
|
return ancestorChangingReferenceScope === void 0;
|
|
}
|
|
}
|
|
function useOuterVariableScopeInParameter(result, location, lastLocation) {
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
const functionLocation = location;
|
|
if (isParameter(lastLocation) && functionLocation.body && result.valueDeclaration && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
|
|
if (target >= 2 /* ES2015 */) {
|
|
const links = getNodeLinks(functionLocation);
|
|
if (links.declarationRequiresScopeChange === void 0) {
|
|
links.declarationRequiresScopeChange = 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 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 173 /* Constructor */:
|
|
return false;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 299 /* PropertyAssignment */:
|
|
return requiresScopeChangeWorker(node.name);
|
|
case 169 /* PropertyDeclaration */:
|
|
if (hasStaticModifier(node)) {
|
|
return target < 99 /* ESNext */ || !useDefineForClassFields;
|
|
}
|
|
return requiresScopeChangeWorker(node.name);
|
|
default:
|
|
if (isNullishCoalesce(node) || isOptionalChain(node)) {
|
|
return target < 7 /* ES2020 */;
|
|
}
|
|
if (isBindingElement(node) && node.dotDotDotToken && isObjectBindingPattern(node.parent)) {
|
|
return target < 4 /* ES2017 */;
|
|
}
|
|
if (isTypeNode(node))
|
|
return false;
|
|
return forEachChild(node, requiresScopeChangeWorker) || false;
|
|
}
|
|
}
|
|
}
|
|
function isConstAssertion(location) {
|
|
return isAssertionExpression(location) && isConstTypeReference(location.type) || isJSDocTypeTag(location) && isConstTypeReference(location.typeExpression);
|
|
}
|
|
function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals = false, 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 _a2, _b, _c;
|
|
const originalLocation = location;
|
|
let result;
|
|
let lastLocation;
|
|
let lastSelfReferenceLocation;
|
|
let propertyWithInvalidInitializer;
|
|
let associatedDeclarationForContainingInitializerOrBindingName;
|
|
let withinDeferredContext = false;
|
|
const errorLocation = location;
|
|
let grandparent;
|
|
let isInExternalModule = false;
|
|
loop:
|
|
while (location) {
|
|
if (name === "const" && isConstAssertion(location)) {
|
|
return void 0;
|
|
}
|
|
if (location.locals && !isGlobalSourceFile(location)) {
|
|
if (result = lookup(location.locals, name, meaning)) {
|
|
let useResult = true;
|
|
if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
|
|
if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 323 /* JSDoc */) {
|
|
useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 166 /* Parameter */ || lastLocation.kind === 343 /* JSDocParameterTag */ || lastLocation.kind === 344 /* JSDocReturnTag */ || lastLocation.kind === 165 /* TypeParameter */ : false;
|
|
}
|
|
if (meaning & result.flags & 3 /* Variable */) {
|
|
if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
|
|
useResult = false;
|
|
} else if (result.flags & 1 /* FunctionScopedVariable */) {
|
|
useResult = lastLocation.kind === 166 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
|
|
}
|
|
}
|
|
} else if (location.kind === 191 /* ConditionalType */) {
|
|
useResult = lastLocation === location.trueType;
|
|
}
|
|
if (useResult) {
|
|
break loop;
|
|
} else {
|
|
result = void 0;
|
|
}
|
|
}
|
|
}
|
|
withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation);
|
|
switch (location.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalOrCommonJsModule(location))
|
|
break;
|
|
isInExternalModule = true;
|
|
case 264 /* ModuleDeclaration */:
|
|
const moduleExports = ((_a2 = getSymbolOfNode(location)) == null ? void 0 : _a2.exports) || emptySymbols;
|
|
if (location.kind === 308 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 16777216 /* Ambient */ && !isGlobalScopeAugmentation(location)) {
|
|
if (result = moduleExports.get("default" /* Default */)) {
|
|
const localSymbol = getLocalSymbolForExportDefault(result);
|
|
if (localSymbol && result.flags & meaning && localSymbol.escapedName === name) {
|
|
break loop;
|
|
}
|
|
result = void 0;
|
|
}
|
|
const moduleExport = moduleExports.get(name);
|
|
if (moduleExport && moduleExport.flags === 2097152 /* Alias */ && (getDeclarationOfKind(moduleExport, 278 /* ExportSpecifier */) || getDeclarationOfKind(moduleExport, 277 /* NamespaceExport */))) {
|
|
break;
|
|
}
|
|
}
|
|
if (name !== "default" /* Default */ && (result = lookup(moduleExports, name, meaning & 2623475 /* ModuleMember */))) {
|
|
if (isSourceFile(location) && location.commonJsModuleIndicator && !((_b = result.declarations) == null ? void 0 : _b.some(isJSDocTypeAlias))) {
|
|
result = void 0;
|
|
} else {
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
if (result = lookup(((_c = getSymbolOfNode(location)) == null ? void 0 : _c.exports) || emptySymbols, name, meaning & 8 /* EnumMember */)) {
|
|
break loop;
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (!isStatic(location)) {
|
|
const ctor = findConstructorDeclaration(location.parent);
|
|
if (ctor && ctor.locals) {
|
|
if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
|
|
Debug.assertNode(location, isPropertyDeclaration);
|
|
propertyWithInvalidInitializer = location;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
if (result = lookup(getSymbolOfNode(location).members || emptySymbols, name, meaning & 788968 /* Type */)) {
|
|
if (!isTypeParameterSymbolDeclaredInContainer(result, location)) {
|
|
result = void 0;
|
|
break;
|
|
}
|
|
if (lastLocation && isStatic(lastLocation)) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
|
|
}
|
|
return void 0;
|
|
}
|
|
break loop;
|
|
}
|
|
if (location.kind === 228 /* ClassExpression */ && meaning & 32 /* Class */) {
|
|
const className = location.name;
|
|
if (className && name === className.escapedText) {
|
|
result = location.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
if (lastLocation === location.expression && location.parent.token === 94 /* ExtendsKeyword */) {
|
|
const container = location.parent.parent;
|
|
if (isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968 /* Type */))) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
break;
|
|
case 164 /* ComputedPropertyName */:
|
|
grandparent = location.parent.parent;
|
|
if (isClassLike(grandparent) || grandparent.kind === 261 /* InterfaceDeclaration */) {
|
|
if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968 /* Type */)) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
|
|
break;
|
|
}
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
if (meaning & 3 /* Variable */ && name === "arguments") {
|
|
result = argumentsSymbol;
|
|
break loop;
|
|
}
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
if (meaning & 3 /* Variable */ && name === "arguments") {
|
|
result = argumentsSymbol;
|
|
break loop;
|
|
}
|
|
if (meaning & 16 /* Function */) {
|
|
const functionName = location.name;
|
|
if (functionName && name === functionName.escapedText) {
|
|
result = location.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 167 /* Decorator */:
|
|
if (location.parent && location.parent.kind === 166 /* Parameter */) {
|
|
location = location.parent;
|
|
}
|
|
if (location.parent && (isClassElement(location.parent) || location.parent.kind === 260 /* ClassDeclaration */)) {
|
|
location = location.parent;
|
|
}
|
|
break;
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
const root = getJSDocRoot(location);
|
|
if (root) {
|
|
location = root.parent;
|
|
}
|
|
break;
|
|
case 166 /* Parameter */:
|
|
if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
|
|
if (!associatedDeclarationForContainingInitializerOrBindingName) {
|
|
associatedDeclarationForContainingInitializerOrBindingName = location;
|
|
}
|
|
}
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
|
|
if (isParameterDeclaration(location) && !associatedDeclarationForContainingInitializerOrBindingName) {
|
|
associatedDeclarationForContainingInitializerOrBindingName = location;
|
|
}
|
|
}
|
|
break;
|
|
case 192 /* InferType */:
|
|
if (meaning & 262144 /* TypeParameter */) {
|
|
const parameterName = location.typeParameter.name;
|
|
if (parameterName && name === parameterName.escapedText) {
|
|
result = location.typeParameter.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (isSelfReferenceLocation(location)) {
|
|
lastSelfReferenceLocation = location;
|
|
}
|
|
lastLocation = location;
|
|
location = isJSDocTemplateTag(location) ? getEffectiveContainerForJSDocTemplateTag(location) || location.parent : isJSDocParameterTag(location) || isJSDocReturnTag(location) ? getHostSignatureFromJSDoc(location) || location.parent : location.parent;
|
|
}
|
|
if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
|
|
result.isReferenced |= meaning;
|
|
}
|
|
if (!result) {
|
|
if (lastLocation) {
|
|
Debug.assert(lastLocation.kind === 308 /* SourceFile */);
|
|
if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
|
|
return lastLocation.symbol;
|
|
}
|
|
}
|
|
if (!excludeGlobals) {
|
|
result = lookup(globals, name, meaning);
|
|
}
|
|
}
|
|
if (!result) {
|
|
if (originalLocation && isInJSFile(originalLocation) && originalLocation.parent) {
|
|
if (isRequireCall(originalLocation.parent, false)) {
|
|
return requireSymbol;
|
|
}
|
|
}
|
|
}
|
|
function checkAndReportErrorForInvalidInitializer() {
|
|
if (propertyWithInvalidInitializer && !(useDefineForClassFields && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
|
|
error(
|
|
errorLocation,
|
|
errorLocation && propertyWithInvalidInitializer.type && textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos) ? Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor : Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
|
|
declarationNameToString(propertyWithInvalidInitializer.name),
|
|
diagnosticName(nameArg)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (!result) {
|
|
if (nameNotFoundMessage) {
|
|
addLazyDiagnostic(() => {
|
|
if (!errorLocation || !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && !checkAndReportErrorForInvalidInitializer() && !checkAndReportErrorForExtendingInterface(errorLocation) && !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
|
|
let suggestion;
|
|
let suggestedLib;
|
|
if (nameArg) {
|
|
suggestedLib = getSuggestedLibForNonExistentName(nameArg);
|
|
if (suggestedLib) {
|
|
error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
|
|
}
|
|
}
|
|
if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
|
|
suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
|
|
const isGlobalScopeAugmentationDeclaration = (suggestion == null ? void 0 : suggestion.valueDeclaration) && isAmbientModule(suggestion.valueDeclaration) && isGlobalScopeAugmentation(suggestion.valueDeclaration);
|
|
if (isGlobalScopeAugmentationDeclaration) {
|
|
suggestion = void 0;
|
|
}
|
|
if (suggestion) {
|
|
const suggestionName = symbolToString(suggestion);
|
|
const isUncheckedJS = isUncheckedJSSuggestion(originalLocation, suggestion, false);
|
|
const message = meaning === 1920 /* Namespace */ || nameArg && typeof nameArg !== "string" && nodeIsSynthesized(nameArg) ? Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 : isUncheckedJS ? Diagnostics.Could_not_find_name_0_Did_you_mean_1 : Diagnostics.Cannot_find_name_0_Did_you_mean_1;
|
|
const diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
|
|
addErrorOrSuggestion(!isUncheckedJS, diagnostic);
|
|
if (suggestion.valueDeclaration) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (!suggestion && !suggestedLib && nameArg) {
|
|
error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
|
|
}
|
|
suggestionCount++;
|
|
}
|
|
});
|
|
}
|
|
return void 0;
|
|
} else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) {
|
|
return void 0;
|
|
}
|
|
if (nameNotFoundMessage) {
|
|
addLazyDiagnostic(() => {
|
|
if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
|
|
const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
|
|
if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
|
|
checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
|
|
}
|
|
}
|
|
if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 8388608 /* JSDoc */)) {
|
|
const merged = getMergedSymbol(result);
|
|
if (length(merged.declarations) && every(merged.declarations, (d) => isNamespaceExportDeclaration(d) || isSourceFile(d) && !!d.symbol.globalExports)) {
|
|
errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));
|
|
}
|
|
}
|
|
if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
|
|
const candidate = getMergedSymbol(getLateBoundSymbol(result));
|
|
const root = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
|
|
if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
|
|
error(errorLocation, Diagnostics.Parameter_0_cannot_reference_itself, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
|
|
} else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) {
|
|
error(errorLocation, Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), declarationNameToString(errorLocation));
|
|
}
|
|
}
|
|
if (result && errorLocation && meaning & 111551 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !isValidTypeOnlyAliasUseSite(errorLocation)) {
|
|
const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* Value */);
|
|
if (typeOnlyDeclaration) {
|
|
const message = typeOnlyDeclaration.kind === 278 /* ExportSpecifier */ ? Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type : Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
|
|
const unescapedName = unescapeLeadingUnderscores(name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(errorLocation, message, unescapedName),
|
|
typeOnlyDeclaration,
|
|
unescapedName
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, unescapedName) {
|
|
if (!typeOnlyDeclaration)
|
|
return diagnostic;
|
|
return addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(
|
|
typeOnlyDeclaration,
|
|
typeOnlyDeclaration.kind === 278 /* ExportSpecifier */ ? Diagnostics._0_was_exported_here : Diagnostics._0_was_imported_here,
|
|
unescapedName
|
|
)
|
|
);
|
|
}
|
|
function getIsDeferredContext(location, lastLocation) {
|
|
if (location.kind !== 216 /* ArrowFunction */ && location.kind !== 215 /* FunctionExpression */) {
|
|
return isTypeQueryNode(location) || (isFunctionLikeDeclaration(location) || location.kind === 169 /* PropertyDeclaration */ && !isStatic(location)) && (!lastLocation || lastLocation !== location.name);
|
|
}
|
|
if (lastLocation && lastLocation === location.name) {
|
|
return false;
|
|
}
|
|
if (location.asteriskToken || hasSyntacticModifier(location, 512 /* Async */)) {
|
|
return true;
|
|
}
|
|
return !getImmediatelyInvokedFunctionExpression(location);
|
|
}
|
|
function isSelfReferenceLocation(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function diagnosticName(nameArg) {
|
|
return isString(nameArg) ? unescapeLeadingUnderscores(nameArg) : declarationNameToString(nameArg);
|
|
}
|
|
function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
|
|
if (symbol.declarations) {
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.kind === 165 /* TypeParameter */) {
|
|
const parent = isJSDocTemplateTag(decl.parent) ? getJSDocHost(decl.parent) : decl.parent;
|
|
if (parent === container) {
|
|
return !(isJSDocTemplateTag(decl.parent) && find(decl.parent.parent.tags, isJSDocTypeAlias));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
|
|
if (!isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) {
|
|
return false;
|
|
}
|
|
const container = getThisContainer(errorLocation, false);
|
|
let location = container;
|
|
while (location) {
|
|
if (isClassLike(location.parent)) {
|
|
const classSymbol = getSymbolOfNode(location.parent);
|
|
if (!classSymbol) {
|
|
break;
|
|
}
|
|
const constructorType = getTypeOfSymbol(classSymbol);
|
|
if (getPropertyOfType(constructorType, name)) {
|
|
error(errorLocation, Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol));
|
|
return true;
|
|
}
|
|
if (location === container && !isStatic(location)) {
|
|
const instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType;
|
|
if (getPropertyOfType(instanceType, name)) {
|
|
error(errorLocation, 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) {
|
|
const expression = getEntityNameForExtendingInterface(errorLocation);
|
|
if (expression && resolveEntityName(expression, 64 /* Interface */, true)) {
|
|
error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getEntityNameForExtendingInterface(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.parent ? getEntityNameForExtendingInterface(node.parent) : void 0;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
if (isEntityNameExpression(node.expression)) {
|
|
return node.expression;
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) {
|
|
const namespaceMeaning = 1920 /* Namespace */ | (isInJSFile(errorLocation) ? 111551 /* Value */ : 0);
|
|
if (meaning === namespaceMeaning) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~namespaceMeaning, void 0, void 0, false));
|
|
const parent = errorLocation.parent;
|
|
if (symbol) {
|
|
if (isQualifiedName(parent)) {
|
|
Debug.assert(parent.left === errorLocation, "Should only be resolving left side of qualified name as a namespace");
|
|
const propName = parent.right.escapedText;
|
|
const propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName);
|
|
if (propType) {
|
|
error(
|
|
parent,
|
|
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,
|
|
unescapeLeadingUnderscores(name),
|
|
unescapeLeadingUnderscores(propName)
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, unescapeLeadingUnderscores(name));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) {
|
|
if (meaning & (788968 /* Type */ & ~1920 /* Namespace */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 /* Type */ & 111551 /* Value */, void 0, void 0, false));
|
|
if (symbol && !(symbol.flags & 1920 /* Namespace */)) {
|
|
error(errorLocation, Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, 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 /* ExportSpecifier */) {
|
|
error(errorLocation, 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 /* Value */) {
|
|
if (isPrimitiveTypeName(name)) {
|
|
if (isExtendedByInterface(errorLocation)) {
|
|
error(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, unescapeLeadingUnderscores(name));
|
|
} else {
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, unescapeLeadingUnderscores(name));
|
|
}
|
|
return true;
|
|
}
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~111551 /* Value */, void 0, void 0, false));
|
|
const allFlags = symbol && getAllSymbolFlags(symbol);
|
|
if (symbol && allFlags !== void 0 && !(allFlags & 111551 /* Value */)) {
|
|
const rawName = unescapeLeadingUnderscores(name);
|
|
if (isES2015OrLaterConstructorName(name)) {
|
|
error(errorLocation, 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, 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, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, rawName);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isExtendedByInterface(node) {
|
|
const grandparent = node.parent.parent;
|
|
const parentOfGrandparent = grandparent.parent;
|
|
if (grandparent && parentOfGrandparent) {
|
|
const isExtending = isHeritageClause(grandparent) && grandparent.token === 94 /* ExtendsKeyword */;
|
|
const isInterface = isInterfaceDeclaration(parentOfGrandparent);
|
|
return isExtending && isInterface;
|
|
}
|
|
return false;
|
|
}
|
|
function maybeMappedType(node, symbol) {
|
|
const container = findAncestor(node.parent, (n) => isComputedPropertyName(n) || isPropertySignature(n) ? false : isTypeLiteralNode(n) || "quit");
|
|
if (container && container.members.length === 1) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
return !!(type.flags & 1048576 /* Union */) && allTypesAssignableToKind(type, 384 /* StringOrNumberLiteral */, 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 /* Value */ & ~788968 /* Type */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* NamespaceModule */, void 0, void 0, false));
|
|
if (symbol) {
|
|
error(
|
|
errorLocation,
|
|
Diagnostics.Cannot_use_namespace_0_as_a_value,
|
|
unescapeLeadingUnderscores(name)
|
|
);
|
|
return true;
|
|
}
|
|
} else if (meaning & (788968 /* Type */ & ~111551 /* Value */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* Module */, void 0, void 0, false));
|
|
if (symbol) {
|
|
error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_type, unescapeLeadingUnderscores(name));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkResolvedBlockScopedVariable(result, errorLocation) {
|
|
var _a2;
|
|
Debug.assert(!!(result.flags & 2 /* BlockScopedVariable */ || result.flags & 32 /* Class */ || result.flags & 384 /* Enum */));
|
|
if (result.flags & (16 /* Function */ | 1 /* FunctionScopedVariable */ | 67108864 /* Assignment */) && result.flags & 32 /* Class */) {
|
|
return;
|
|
}
|
|
const declaration = (_a2 = result.declarations) == null ? void 0 : _a2.find(
|
|
(d) => isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 263 /* EnumDeclaration */
|
|
);
|
|
if (declaration === void 0)
|
|
return Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration");
|
|
if (!(declaration.flags & 16777216 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
|
|
let diagnosticMessage;
|
|
const declarationName = declarationNameToString(getNameOfDeclaration(declaration));
|
|
if (result.flags & 2 /* BlockScopedVariable */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName);
|
|
} else if (result.flags & 32 /* Class */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
|
|
} else if (result.flags & 256 /* RegularEnum */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
|
|
} else {
|
|
Debug.assert(!!(result.flags & 128 /* ConstEnum */));
|
|
if (shouldPreserveConstEnums(compilerOptions)) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
|
|
}
|
|
}
|
|
if (diagnosticMessage) {
|
|
addRelatedInfo(
|
|
diagnosticMessage,
|
|
createDiagnosticForNode(declaration, Diagnostics._0_is_declared_here, declarationName)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function isSameScopeDescendentOf(initial, parent, stopAt) {
|
|
return !!parent && !!findAncestor(initial, (n) => n === parent || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || isAsyncFunction(n)) ? "quit" : false));
|
|
}
|
|
function getAnyImportSyntax(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node;
|
|
case 270 /* ImportClause */:
|
|
return node.parent;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.parent;
|
|
case 273 /* ImportSpecifier */:
|
|
return node.parent.parent.parent;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getDeclarationOfAliasSymbol(symbol) {
|
|
return symbol.declarations && findLast(symbol.declarations, isAliasSymbolDeclaration);
|
|
}
|
|
function isAliasSymbolDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ || node.kind === 267 /* NamespaceExportDeclaration */ || node.kind === 270 /* ImportClause */ && !!node.name || node.kind === 271 /* NamespaceImport */ || node.kind === 277 /* NamespaceExport */ || node.kind === 273 /* ImportSpecifier */ || node.kind === 278 /* ExportSpecifier */ || node.kind === 274 /* ExportAssignment */ && exportAssignmentIsAlias(node) || isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) || isAccessExpression(node) && isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableOrJsExpression(node.parent.right) || node.kind === 300 /* ShorthandPropertyAssignment */ || node.kind === 299 /* PropertyAssignment */ && isAliasableOrJsExpression(node.initializer) || node.kind === 257 /* VariableDeclaration */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node) || node.kind === 205 /* BindingElement */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node.parent.parent);
|
|
}
|
|
function isAliasableOrJsExpression(e) {
|
|
return isAliasableExpression(e) || isFunctionExpression(e) && isJSConstructor(e);
|
|
}
|
|
function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) {
|
|
const commonJSPropertyAccess = getCommonJSPropertyAccess(node);
|
|
if (commonJSPropertyAccess) {
|
|
const name = getLeftmostAccessExpression(commonJSPropertyAccess.expression).arguments[0];
|
|
return isIdentifier(commonJSPropertyAccess.name) ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), commonJSPropertyAccess.name.escapedText)) : void 0;
|
|
}
|
|
if (isVariableDeclaration(node) || node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
const immediate = resolveExternalModuleName(
|
|
node,
|
|
getExternalModuleRequireArgument(node) || getExternalModuleImportEqualsDeclarationExpression(node)
|
|
);
|
|
const resolved2 = resolveExternalModuleSymbol(immediate);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved2, false);
|
|
return resolved2;
|
|
}
|
|
const resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias);
|
|
checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved);
|
|
return resolved;
|
|
}
|
|
function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
|
|
if (markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false) && !node.isTypeOnly) {
|
|
const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
|
|
const isExport = typeOnlyDeclaration.kind === 278 /* ExportSpecifier */;
|
|
const message = isExport ? Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type : Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type;
|
|
const relatedMessage = isExport ? Diagnostics._0_was_exported_here : Diagnostics._0_was_imported_here;
|
|
const name = unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText);
|
|
addRelatedInfo(error(node.moduleReference, message), createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name));
|
|
}
|
|
}
|
|
function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) {
|
|
const exportValue = moduleSymbol.exports.get("export=" /* ExportEquals */);
|
|
const exportSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), name) : moduleSymbol.exports.get(name);
|
|
const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
function isSyntacticDefault(node) {
|
|
return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node);
|
|
}
|
|
function getUsageModeForExpression(usage) {
|
|
return isStringLiteralLike(usage) ? getModeForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
|
|
}
|
|
function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
|
|
return usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */;
|
|
}
|
|
function isOnlyImportedAsDefault(usage) {
|
|
const usageMode = getUsageModeForExpression(usage);
|
|
return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */);
|
|
}
|
|
function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
|
|
const usageMode = file && getUsageModeForExpression(usage);
|
|
if (file && usageMode !== void 0) {
|
|
const result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat);
|
|
if (usageMode === 99 /* ESNext */ || result) {
|
|
return result;
|
|
}
|
|
}
|
|
if (!allowSyntheticDefaultImports) {
|
|
return false;
|
|
}
|
|
if (!file || file.isDeclarationFile) {
|
|
const defaultExportSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, void 0, true);
|
|
if (defaultExportSymbol && some(defaultExportSymbol.declarations, isSyntacticDefault)) {
|
|
return false;
|
|
}
|
|
if (resolveExportByName(moduleSymbol, escapeLeadingUnderscores("__esModule"), void 0, dontResolveAlias)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (!isSourceFileJS(file)) {
|
|
return hasExportAssignmentSymbol(moduleSymbol);
|
|
}
|
|
return typeof file.externalModuleIndicator !== "object" && !resolveExportByName(moduleSymbol, escapeLeadingUnderscores("__esModule"), void 0, dontResolveAlias);
|
|
}
|
|
function getTargetOfImportClause(node, dontResolveAlias) {
|
|
const moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias);
|
|
}
|
|
}
|
|
function getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias) {
|
|
var _a2;
|
|
let exportDefaultSymbol;
|
|
if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
exportDefaultSymbol = moduleSymbol;
|
|
} else {
|
|
exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
|
|
}
|
|
const file = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
if (!specifier) {
|
|
return exportDefaultSymbol;
|
|
}
|
|
const hasDefaultOnly = isOnlyImportedAsDefault(specifier);
|
|
const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier);
|
|
if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
|
|
if (hasExportAssignmentSymbol(moduleSymbol)) {
|
|
const compilerOptionName = moduleKind >= 5 /* ES2015 */ ? "allowSyntheticDefaultImports" : "esModuleInterop";
|
|
const exportEqualsSymbol = moduleSymbol.exports.get("export=" /* ExportEquals */);
|
|
const exportAssignment = exportEqualsSymbol.valueDeclaration;
|
|
const err = error(node.name, Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName);
|
|
if (exportAssignment) {
|
|
addRelatedInfo(err, createDiagnosticForNode(
|
|
exportAssignment,
|
|
Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag,
|
|
compilerOptionName
|
|
));
|
|
}
|
|
} else if (isImportClause(node)) {
|
|
reportNonDefaultExport(moduleSymbol, node);
|
|
} else {
|
|
errorNoModuleMemberSymbol(moduleSymbol, moduleSymbol, node, isImportOrExportSpecifier(node) && node.propertyName || node.name);
|
|
}
|
|
} else if (hasSyntheticDefault || hasDefaultOnly) {
|
|
const resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, void 0, false);
|
|
return exportDefaultSymbol;
|
|
}
|
|
function getModuleSpecifierForImportOrExport(node) {
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
return node.parent.moduleSpecifier;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return isExternalModuleReference(node.moduleReference) ? node.moduleReference.expression : void 0;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.parent.moduleSpecifier;
|
|
case 273 /* ImportSpecifier */:
|
|
return node.parent.parent.parent.moduleSpecifier;
|
|
case 278 /* ExportSpecifier */:
|
|
return node.parent.parent.moduleSpecifier;
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function reportNonDefaultExport(moduleSymbol, node) {
|
|
var _a2, _b, _c;
|
|
if ((_a2 = moduleSymbol.exports) == null ? void 0 : _a2.has(node.symbol.escapedName)) {
|
|
error(
|
|
node.name,
|
|
Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead,
|
|
symbolToString(moduleSymbol),
|
|
symbolToString(node.symbol)
|
|
);
|
|
} else {
|
|
const diagnostic = error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
|
|
const exportStar = (_b = moduleSymbol.exports) == null ? void 0 : _b.get("__export" /* ExportStar */);
|
|
if (exportStar) {
|
|
const defaultExport = (_c = exportStar.declarations) == null ? void 0 : _c.find((decl) => {
|
|
var _a3, _b2;
|
|
return !!(isExportDeclaration(decl) && decl.moduleSpecifier && ((_b2 = (_a3 = resolveExternalModuleName(decl, decl.moduleSpecifier)) == null ? void 0 : _a3.exports) == null ? void 0 : _b2.has("default" /* Default */)));
|
|
});
|
|
if (defaultExport) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(defaultExport, Diagnostics.export_Asterisk_does_not_re_export_a_default));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTargetOfNamespaceImport(node, dontResolveAlias) {
|
|
const moduleSpecifier = node.parent.parent.moduleSpecifier;
|
|
const immediate = resolveExternalModuleName(node, moduleSpecifier);
|
|
const resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfNamespaceExport(node, dontResolveAlias) {
|
|
const moduleSpecifier = node.parent.moduleSpecifier;
|
|
const immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier);
|
|
const resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
|
|
return resolved;
|
|
}
|
|
function combineValueAndTypeSymbols(valueSymbol, typeSymbol) {
|
|
if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) {
|
|
return unknownSymbol;
|
|
}
|
|
if (valueSymbol.flags & (788968 /* Type */ | 1920 /* Namespace */)) {
|
|
return valueSymbol;
|
|
}
|
|
const result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
|
|
result.declarations = deduplicate(concatenate(valueSymbol.declarations, typeSymbol.declarations), equateValues);
|
|
result.parent = valueSymbol.parent || typeSymbol.parent;
|
|
if (valueSymbol.valueDeclaration)
|
|
result.valueDeclaration = valueSymbol.valueDeclaration;
|
|
if (typeSymbol.members)
|
|
result.members = new Map(typeSymbol.members);
|
|
if (valueSymbol.exports)
|
|
result.exports = new Map(valueSymbol.exports);
|
|
return result;
|
|
}
|
|
function getExportOfModule(symbol, name, specifier, dontResolveAlias) {
|
|
if (symbol.flags & 1536 /* Module */) {
|
|
const exportSymbol = getExportsOfSymbol(symbol).get(name.escapedText);
|
|
const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
}
|
|
function getPropertyOfVariable(symbol, name) {
|
|
if (symbol.flags & 3 /* Variable */) {
|
|
const typeAnnotation = symbol.valueDeclaration.type;
|
|
if (typeAnnotation) {
|
|
return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
|
|
}
|
|
}
|
|
}
|
|
function getExternalModuleMember(node, specifier, dontResolveAlias = false) {
|
|
var _a2;
|
|
const moduleSpecifier = getExternalModuleRequireArgument(node) || node.moduleSpecifier;
|
|
const moduleSymbol = resolveExternalModuleName(node, moduleSpecifier);
|
|
const name = !isPropertyAccessExpression(specifier) && specifier.propertyName || specifier.name;
|
|
if (!isIdentifier(name)) {
|
|
return void 0;
|
|
}
|
|
const suppressInteropError = name.escapedText === "default" /* Default */ && !!(compilerOptions.allowSyntheticDefaultImports || getESModuleInterop(compilerOptions));
|
|
const targetSymbol = resolveESModuleSymbol(moduleSymbol, moduleSpecifier, false, suppressInteropError);
|
|
if (targetSymbol) {
|
|
if (name.escapedText) {
|
|
if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
return moduleSymbol;
|
|
}
|
|
let symbolFromVariable;
|
|
if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=" /* ExportEquals */)) {
|
|
symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText, true);
|
|
} else {
|
|
symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText);
|
|
}
|
|
symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
|
|
let symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
|
|
if (symbolFromModule === void 0 && name.escapedText === "default" /* Default */) {
|
|
const file = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
|
|
symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
|
|
}
|
|
}
|
|
const 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 _a2;
|
|
const moduleName = getFullyQualifiedName(moduleSymbol, node);
|
|
const declarationName = declarationNameToString(name);
|
|
const suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol);
|
|
if (suggestion !== void 0) {
|
|
const suggestionName = symbolToString(suggestion);
|
|
const diagnostic = error(name, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName);
|
|
if (suggestion.valueDeclaration) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
|
|
);
|
|
}
|
|
} else {
|
|
if ((_a2 = moduleSymbol.exports) == null ? void 0 : _a2.has("default" /* Default */)) {
|
|
error(
|
|
name,
|
|
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 _a2, _b;
|
|
const localSymbol = (_b = (_a2 = moduleSymbol.valueDeclaration) == null ? void 0 : _a2.locals) == null ? void 0 : _b.get(name.escapedText);
|
|
const exports = moduleSymbol.exports;
|
|
if (localSymbol) {
|
|
const exportedEqualsSymbol = exports == null ? void 0 : exports.get("export=" /* ExportEquals */);
|
|
if (exportedEqualsSymbol) {
|
|
getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) : error(name, Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
|
|
} else {
|
|
const exportedSymbol = exports ? find(symbolsToArray(exports), (symbol) => !!getSymbolIfSameReference(symbol, localSymbol)) : void 0;
|
|
const diagnostic = exportedSymbol ? error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) : error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
|
|
if (localSymbol.declarations) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
...map(localSymbol.declarations, (decl, index) => createDiagnosticForNode(decl, index === 0 ? Diagnostics._0_is_declared_here : Diagnostics.and_here, declarationName))
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
error(name, Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
|
|
}
|
|
}
|
|
function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) {
|
|
if (moduleKind >= 5 /* ES2015 */) {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_a_default_import : Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
|
|
error(name, message, declarationName);
|
|
} else {
|
|
if (isInJSFile(node)) {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import : 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 {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import : 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 (isImportSpecifier(node) && idText(node.propertyName || node.name) === "default" /* Default */) {
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
const moduleSymbol = specifier && resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias);
|
|
}
|
|
}
|
|
const root = isBindingElement(node) ? getRootDeclaration(node) : node.parent.parent.parent;
|
|
const commonJSPropertyAccess = getCommonJSPropertyAccess(root);
|
|
const resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias);
|
|
const name = node.propertyName || node.name;
|
|
if (commonJSPropertyAccess && resolved && isIdentifier(name)) {
|
|
return resolveSymbol(getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText), dontResolveAlias);
|
|
}
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getCommonJSPropertyAccess(node) {
|
|
if (isVariableDeclaration(node) && node.initializer && isPropertyAccessExpression(node.initializer)) {
|
|
return node.initializer;
|
|
}
|
|
}
|
|
function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) {
|
|
const resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) {
|
|
if (idText(node.propertyName || node.name) === "default" /* Default */) {
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
const moduleSymbol = specifier && resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, !!dontResolveAlias);
|
|
}
|
|
}
|
|
const resolved = node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : resolveEntityName(node.propertyName || node.name, meaning, false, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfExportAssignment(node, dontResolveAlias) {
|
|
const expression = isExportAssignment(node) ? node.expression : node.right;
|
|
const resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfAliasLikeExpression(expression, dontResolveAlias) {
|
|
if (isClassExpression(expression)) {
|
|
return checkExpressionCached(expression).symbol;
|
|
}
|
|
if (!isEntityName(expression) && !isEntityNameExpression(expression)) {
|
|
return void 0;
|
|
}
|
|
const aliasLike = resolveEntityName(expression, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, true, dontResolveAlias);
|
|
if (aliasLike) {
|
|
return aliasLike;
|
|
}
|
|
checkExpressionCached(expression);
|
|
return getNodeLinks(expression).resolvedSymbol;
|
|
}
|
|
function getTargetOfAccessExpression(node, dontRecursivelyResolve) {
|
|
if (!(isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */)) {
|
|
return void 0;
|
|
}
|
|
return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve);
|
|
}
|
|
function getTargetOfAliasDeclaration(node, dontRecursivelyResolve = false) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 257 /* VariableDeclaration */:
|
|
return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve);
|
|
case 270 /* ImportClause */:
|
|
return getTargetOfImportClause(node, dontRecursivelyResolve);
|
|
case 271 /* NamespaceImport */:
|
|
return getTargetOfNamespaceImport(node, dontRecursivelyResolve);
|
|
case 277 /* NamespaceExport */:
|
|
return getTargetOfNamespaceExport(node, dontRecursivelyResolve);
|
|
case 273 /* ImportSpecifier */:
|
|
case 205 /* BindingElement */:
|
|
return getTargetOfImportSpecifier(node, dontRecursivelyResolve);
|
|
case 278 /* ExportSpecifier */:
|
|
return getTargetOfExportSpecifier(node, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, dontRecursivelyResolve);
|
|
case 274 /* ExportAssignment */:
|
|
case 223 /* BinaryExpression */:
|
|
return getTargetOfExportAssignment(node, dontRecursivelyResolve);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return resolveEntityName(node.name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, true, dontRecursivelyResolve);
|
|
case 299 /* PropertyAssignment */:
|
|
return getTargetOfAliasLikeExpression(node.initializer, dontRecursivelyResolve);
|
|
case 209 /* ElementAccessExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return getTargetOfAccessExpression(node, dontRecursivelyResolve);
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function isNonLocalAlias(symbol, excludes = 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */) {
|
|
if (!symbol)
|
|
return false;
|
|
return (symbol.flags & (2097152 /* Alias */ | excludes)) === 2097152 /* Alias */ || !!(symbol.flags & 2097152 /* Alias */ && symbol.flags & 67108864 /* Assignment */);
|
|
}
|
|
function resolveSymbol(symbol, dontResolveAlias) {
|
|
return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol;
|
|
}
|
|
function resolveAlias(symbol) {
|
|
Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.aliasTarget) {
|
|
links.aliasTarget = resolvingSymbol;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
const target = getTargetOfAliasDeclaration(node);
|
|
if (links.aliasTarget === resolvingSymbol) {
|
|
links.aliasTarget = target || unknownSymbol;
|
|
} else {
|
|
error(node, Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
|
|
}
|
|
} else if (links.aliasTarget === resolvingSymbol) {
|
|
links.aliasTarget = unknownSymbol;
|
|
}
|
|
return links.aliasTarget;
|
|
}
|
|
function tryResolveAlias(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.aliasTarget !== resolvingSymbol) {
|
|
return resolveAlias(symbol);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAllSymbolFlags(symbol) {
|
|
let flags = symbol.flags;
|
|
let seenSymbols;
|
|
while (symbol.flags & 2097152 /* Alias */) {
|
|
const target = resolveAlias(symbol);
|
|
if (target === unknownSymbol) {
|
|
return 67108863 /* All */;
|
|
}
|
|
if (target === symbol || (seenSymbols == null ? void 0 : seenSymbols.has(target))) {
|
|
break;
|
|
}
|
|
if (target.flags & 2097152 /* Alias */) {
|
|
if (seenSymbols) {
|
|
seenSymbols.add(target);
|
|
} else {
|
|
seenSymbols = /* @__PURE__ */ new Set([symbol, target]);
|
|
}
|
|
}
|
|
flags |= target.flags;
|
|
symbol = target;
|
|
}
|
|
return flags;
|
|
}
|
|
function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) {
|
|
if (!aliasDeclaration || isPropertyAccessExpression(aliasDeclaration))
|
|
return false;
|
|
const sourceSymbol = getSymbolOfNode(aliasDeclaration);
|
|
if (isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) {
|
|
const links2 = getSymbolLinks(sourceSymbol);
|
|
links2.typeOnlyDeclaration = aliasDeclaration;
|
|
return true;
|
|
}
|
|
const links = getSymbolLinks(sourceSymbol);
|
|
return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty) || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty);
|
|
}
|
|
function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) {
|
|
var _a2, _b, _c;
|
|
if (target && (aliasDeclarationLinks.typeOnlyDeclaration === void 0 || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) {
|
|
const exportSymbol = (_b = (_a2 = target.exports) == null ? void 0 : _a2.get("export=" /* ExportEquals */)) != null ? _b : target;
|
|
const typeOnly = exportSymbol.declarations && find(exportSymbol.declarations, isTypeOnlyImportOrExportDeclaration);
|
|
aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly != null ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) != null ? _c : false;
|
|
}
|
|
return !!aliasDeclarationLinks.typeOnlyDeclaration;
|
|
}
|
|
function getTypeOnlyAliasDeclaration(symbol, include) {
|
|
if (!(symbol.flags & 2097152 /* Alias */)) {
|
|
return void 0;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
if (include === void 0) {
|
|
return links.typeOnlyDeclaration || void 0;
|
|
}
|
|
if (links.typeOnlyDeclaration) {
|
|
return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function markExportAsReferenced(node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const target = resolveAlias(symbol);
|
|
if (target) {
|
|
const markAlias = target === unknownSymbol || getAllSymbolFlags(target) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
|
|
if (markAlias) {
|
|
markAliasSymbolAsReferenced(symbol);
|
|
}
|
|
}
|
|
}
|
|
function markAliasSymbolAsReferenced(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.referenced) {
|
|
links.referenced = true;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
if (isInternalModuleImportEqualsDeclaration(node)) {
|
|
if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
|
|
checkExpressionCached(node.moduleReference);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function markConstEnumAliasAsReferenced(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.constEnumReferenced) {
|
|
links.constEnumReferenced = true;
|
|
}
|
|
}
|
|
function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
|
|
if (entityName.kind === 79 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
|
|
entityName = entityName.parent;
|
|
}
|
|
if (entityName.kind === 79 /* Identifier */ || entityName.parent.kind === 163 /* QualifiedName */) {
|
|
return resolveEntityName(entityName, 1920 /* Namespace */, false, dontResolveAlias);
|
|
} else {
|
|
Debug.assert(entityName.parent.kind === 268 /* ImportEqualsDeclaration */);
|
|
return resolveEntityName(entityName, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, false, dontResolveAlias);
|
|
}
|
|
}
|
|
function getFullyQualifiedName(symbol, containingLocation) {
|
|
return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, void 0, 32 /* DoNotIncludeSymbolChain */ | 4 /* AllowAnyNodeKind */);
|
|
}
|
|
function getContainingQualifiedNameNode(node) {
|
|
while (isQualifiedName(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetQualifiedNameAsValue(node) {
|
|
let left = getFirstIdentifier(node);
|
|
let symbol = resolveName(left, left.escapedText, 111551 /* Value */, void 0, left, true);
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
while (isQualifiedName(left.parent)) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
symbol = getPropertyOfType(type, left.parent.right.escapedText);
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
left = left.parent;
|
|
}
|
|
return symbol;
|
|
}
|
|
function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location) {
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
const namespaceMeaning = 1920 /* Namespace */ | (isInJSFile(name) ? meaning & 111551 /* Value */ : 0);
|
|
let symbol;
|
|
if (name.kind === 79 /* Identifier */) {
|
|
const message = meaning === namespaceMeaning || nodeIsSynthesized(name) ? Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(getFirstIdentifier(name));
|
|
const symbolFromJSPrototype = isInJSFile(name) && !nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : void 0;
|
|
symbol = getMergedSymbol(resolveName(location || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? void 0 : message, name, true, false));
|
|
if (!symbol) {
|
|
return getMergedSymbol(symbolFromJSPrototype);
|
|
}
|
|
} else if (name.kind === 163 /* QualifiedName */ || name.kind === 208 /* PropertyAccessExpression */) {
|
|
const left = name.kind === 163 /* QualifiedName */ ? name.left : name.expression;
|
|
const right = name.kind === 163 /* QualifiedName */ ? name.right : name.name;
|
|
let namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, false, location);
|
|
if (!namespace || nodeIsMissing(right)) {
|
|
return void 0;
|
|
} else if (namespace === unknownSymbol) {
|
|
return namespace;
|
|
}
|
|
if (namespace.valueDeclaration && isInJSFile(namespace.valueDeclaration) && isVariableDeclaration(namespace.valueDeclaration) && namespace.valueDeclaration.initializer && isCommonJsRequire(namespace.valueDeclaration.initializer)) {
|
|
const moduleName = namespace.valueDeclaration.initializer.arguments[0];
|
|
const moduleSym = resolveExternalModuleName(moduleName, moduleName);
|
|
if (moduleSym) {
|
|
const resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
|
|
if (resolvedModuleSymbol) {
|
|
namespace = resolvedModuleSymbol;
|
|
}
|
|
}
|
|
}
|
|
symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning));
|
|
if (!symbol) {
|
|
if (!ignoreErrors) {
|
|
const namespaceName = getFullyQualifiedName(namespace);
|
|
const declarationName = declarationNameToString(right);
|
|
const suggestionForNonexistentModule = getSuggestedSymbolForNonexistentModule(right, namespace);
|
|
if (suggestionForNonexistentModule) {
|
|
error(right, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, namespaceName, declarationName, symbolToString(suggestionForNonexistentModule));
|
|
return void 0;
|
|
}
|
|
const containingQualifiedName = isQualifiedName(name) && getContainingQualifiedNameNode(name);
|
|
const canSuggestTypeof = globalObjectType && meaning & 788968 /* Type */ && containingQualifiedName && !isTypeOfExpression(containingQualifiedName.parent) && tryGetQualifiedNameAsValue(containingQualifiedName);
|
|
if (canSuggestTypeof) {
|
|
error(
|
|
containingQualifiedName,
|
|
Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0,
|
|
entityNameToString(containingQualifiedName)
|
|
);
|
|
return void 0;
|
|
}
|
|
if (meaning & 1920 /* Namespace */ && isQualifiedName(name.parent)) {
|
|
const exportedTypeSymbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, 788968 /* Type */));
|
|
if (exportedTypeSymbol) {
|
|
error(
|
|
name.parent.right,
|
|
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),
|
|
unescapeLeadingUnderscores(name.parent.right.escapedText)
|
|
);
|
|
return void 0;
|
|
}
|
|
}
|
|
error(right, Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName);
|
|
}
|
|
return void 0;
|
|
}
|
|
} else {
|
|
throw Debug.assertNever(name, "Unknown entity name kind.");
|
|
}
|
|
Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
|
|
if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 274 /* ExportAssignment */)) {
|
|
markSymbolOfAliasDeclarationIfTypeOnly(getAliasDeclarationFromName(name), symbol, void 0, true);
|
|
}
|
|
return symbol.flags & meaning || dontResolveAlias ? symbol : resolveAlias(symbol);
|
|
}
|
|
function resolveEntityNameFromAssignmentDeclaration(name, meaning) {
|
|
if (isJSDocTypeReference(name.parent)) {
|
|
const secondaryLocation = getAssignmentDeclarationLocation(name.parent);
|
|
if (secondaryLocation) {
|
|
return resolveName(secondaryLocation, name.escapedText, meaning, void 0, name, true);
|
|
}
|
|
}
|
|
}
|
|
function getAssignmentDeclarationLocation(node) {
|
|
const typeAlias = findAncestor(node, (node2) => !(isJSDocNode(node2) || node2.flags & 8388608 /* JSDoc */) ? "quit" : isJSDocTypeAlias(node2));
|
|
if (typeAlias) {
|
|
return;
|
|
}
|
|
const host2 = getJSDocHost(node);
|
|
if (host2 && isExpressionStatement(host2) && isPrototypePropertyAssignment(host2.expression)) {
|
|
const symbol = getSymbolOfNode(host2.expression.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
if (host2 && isFunctionExpression(host2) && isPrototypePropertyAssignment(host2.parent) && isExpressionStatement(host2.parent.parent)) {
|
|
const symbol = getSymbolOfNode(host2.parent.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
if (host2 && (isObjectLiteralMethod(host2) || isPropertyAssignment(host2)) && isBinaryExpression(host2.parent.parent) && getAssignmentDeclarationKind(host2.parent.parent) === 6 /* Prototype */) {
|
|
const symbol = getSymbolOfNode(host2.parent.parent.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
const sig = getEffectiveJSDocHost(node);
|
|
if (sig && isFunctionLike(sig)) {
|
|
const symbol = getSymbolOfNode(sig);
|
|
return symbol && symbol.valueDeclaration;
|
|
}
|
|
}
|
|
function getDeclarationOfJSPrototypeContainer(symbol) {
|
|
const decl = symbol.parent.valueDeclaration;
|
|
if (!decl) {
|
|
return void 0;
|
|
}
|
|
const initializer = isAssignmentDeclaration(decl) ? getAssignedExpandoInitializer(decl) : hasOnlyExpressionInitializer(decl) ? getDeclaredExpandoInitializer(decl) : void 0;
|
|
return initializer || decl;
|
|
}
|
|
function getExpandoSymbol(symbol) {
|
|
const decl = symbol.valueDeclaration;
|
|
if (!decl || !isInJSFile(decl) || symbol.flags & 524288 /* TypeAlias */ || getExpandoInitializer(decl, false)) {
|
|
return void 0;
|
|
}
|
|
const init = isVariableDeclaration(decl) ? getDeclaredExpandoInitializer(decl) : getAssignedExpandoInitializer(decl);
|
|
if (init) {
|
|
const initSymbol = getSymbolOfNode(init);
|
|
if (initSymbol) {
|
|
return mergeJSSymbols(initSymbol, symbol);
|
|
}
|
|
}
|
|
}
|
|
function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) {
|
|
const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */;
|
|
const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
|
|
return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? void 0 : errorMessage);
|
|
}
|
|
function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, isForAugmentation = false) {
|
|
return isStringLiteralLike(moduleReferenceExpression) ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation) : void 0;
|
|
}
|
|
function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation = false) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h;
|
|
if (startsWith(moduleReference, "@types/")) {
|
|
const diag2 = Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
|
|
const withoutAtTypePrefix = removePrefix(moduleReference, "@types/");
|
|
error(errorNode, diag2, withoutAtTypePrefix, moduleReference);
|
|
}
|
|
const ambientModule = tryFindAmbientModule(moduleReference, true);
|
|
if (ambientModule) {
|
|
return ambientModule;
|
|
}
|
|
const currentSourceFile = getSourceFileOfNode(location);
|
|
const contextSpecifier = isStringLiteralLike(location) ? location : ((_a2 = findAncestor(location, isImportCall)) == null ? void 0 : _a2.arguments[0]) || ((_b = findAncestor(location, isImportDeclaration)) == null ? void 0 : _b.moduleSpecifier) || ((_c = findAncestor(location, isExternalModuleImportEqualsDeclaration)) == null ? void 0 : _c.moduleReference.expression) || ((_d = findAncestor(location, isExportDeclaration)) == null ? void 0 : _d.moduleSpecifier) || ((_e = isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : void 0) == null ? void 0 : _e.name) || ((_f = isLiteralImportTypeNode(location) ? location : void 0) == null ? void 0 : _f.argument.literal);
|
|
const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
|
|
const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode);
|
|
const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule);
|
|
const sourceFile = resolvedModule && (!resolutionDiagnostic || resolutionDiagnostic === Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set) && host.getSourceFile(resolvedModule.resolvedFileName);
|
|
if (sourceFile) {
|
|
if (resolutionDiagnostic) {
|
|
error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
|
|
}
|
|
if (sourceFile.symbol) {
|
|
if (resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
|
|
errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
const isSyncImport = currentSourceFile.impliedNodeFormat === 1 /* CommonJS */ && !findAncestor(location, isImportCall) || !!findAncestor(location, isImportEqualsDeclaration);
|
|
const overrideClauseHost = findAncestor(location, (l) => isImportTypeNode(l) || isExportDeclaration(l) || isImportDeclaration(l));
|
|
const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? (_g = overrideClauseHost.assertions) == null ? void 0 : _g.assertClause : overrideClauseHost == null ? void 0 : overrideClauseHost.assertClause;
|
|
if (isSyncImport && sourceFile.impliedNodeFormat === 99 /* ESNext */ && !getResolutionModeOverrideForClause(overrideClause)) {
|
|
if (findAncestor(location, isImportEqualsDeclaration)) {
|
|
error(errorNode, 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 {
|
|
let diagnosticDetails;
|
|
const ext = tryGetExtensionFromPath2(currentSourceFile.fileName);
|
|
if (ext === ".ts" /* Ts */ || ext === ".js" /* Js */ || ext === ".tsx" /* Tsx */ || ext === ".jsx" /* Jsx */) {
|
|
const scope = currentSourceFile.packageJsonScope;
|
|
const targetExt = ext === ".ts" /* Ts */ ? ".mts" /* Mts */ : ext === ".js" /* Js */ ? ".mjs" /* Mjs */ : void 0;
|
|
if (scope && !scope.contents.packageJsonContent.type) {
|
|
if (targetExt) {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
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,
|
|
combinePaths(scope.packageDirectory, "package.json")
|
|
);
|
|
} else {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0,
|
|
combinePaths(scope.packageDirectory, "package.json")
|
|
);
|
|
}
|
|
} else {
|
|
if (targetExt) {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
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 = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module
|
|
);
|
|
}
|
|
}
|
|
}
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(errorNode, chainDiagnosticMessages(
|
|
diagnosticDetails,
|
|
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
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
return getMergedSymbol(sourceFile.symbol);
|
|
}
|
|
if (moduleNotFoundError) {
|
|
error(errorNode, Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (patternAmbientModules) {
|
|
const pattern = findBestPatternMatch(patternAmbientModules, (_) => _.pattern, moduleReference);
|
|
if (pattern) {
|
|
const augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference);
|
|
if (augmentation) {
|
|
return getMergedSymbol(augmentation);
|
|
}
|
|
return getMergedSymbol(pattern.symbol);
|
|
}
|
|
}
|
|
if (resolvedModule && !resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === void 0 || resolutionDiagnostic === Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) {
|
|
if (isForAugmentation) {
|
|
const diag2 = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;
|
|
error(errorNode, diag2, moduleReference, resolvedModule.resolvedFileName);
|
|
} else {
|
|
errorOnImplicitAnyModule(noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (moduleNotFoundError) {
|
|
if (resolvedModule) {
|
|
const redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName);
|
|
if (redirect) {
|
|
error(errorNode, Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName);
|
|
return void 0;
|
|
}
|
|
}
|
|
if (resolutionDiagnostic) {
|
|
error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
|
|
} else {
|
|
const tsExtension = tryExtractTSExtension(moduleReference);
|
|
const isExtensionlessRelativePathImport = pathIsRelative(moduleReference) && !hasExtension(moduleReference);
|
|
const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
|
|
const resolutionIsNode16OrNext = moduleResolutionKind === 3 /* Node16 */ || moduleResolutionKind === 99 /* NodeNext */;
|
|
if (tsExtension) {
|
|
const diag2 = Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
|
|
const importSourceWithoutExtension = removeExtension(moduleReference, tsExtension);
|
|
let replacedImportSource = importSourceWithoutExtension;
|
|
if (moduleKind >= 5 /* ES2015 */) {
|
|
replacedImportSource += tsExtension === ".mts" /* Mts */ ? ".mjs" : tsExtension === ".cts" /* Cts */ ? ".cjs" : ".js";
|
|
}
|
|
error(errorNode, diag2, tsExtension, replacedImportSource);
|
|
} else if (!compilerOptions.resolveJsonModule && fileExtensionIs(moduleReference, ".json" /* Json */) && getEmitModuleResolutionKind(compilerOptions) !== 1 /* Classic */ && hasJsonModuleEmitEnabled(compilerOptions)) {
|
|
error(errorNode, Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
|
|
} else if (mode === 99 /* ESNext */ && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) {
|
|
const absoluteRef = getNormalizedAbsolutePath(moduleReference, getDirectoryPath(currentSourceFile.path));
|
|
const suggestedExt = (_h = suggestedExtensions.find(([actualExt, _importExt]) => host.fileExists(absoluteRef + actualExt))) == null ? void 0 : _h[1];
|
|
if (suggestedExt) {
|
|
error(
|
|
errorNode,
|
|
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, 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 void 0;
|
|
}
|
|
function errorOnImplicitAnyModule(isError, errorNode, { packageId, resolvedFileName }, moduleReference) {
|
|
const errorInfo = !isExternalModuleNameRelative(moduleReference) && packageId ? typesPackageExists(packageId.name) ? chainDiagnosticMessages(
|
|
void 0,
|
|
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,
|
|
mangleScopedPackageName(packageId.name)
|
|
) : packageBundlesTypes(packageId.name) ? chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1,
|
|
packageId.name,
|
|
moduleReference
|
|
) : chainDiagnosticMessages(
|
|
void 0,
|
|
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,
|
|
mangleScopedPackageName(packageId.name)
|
|
) : void 0;
|
|
errorOrSuggestion(isError, errorNode, chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type,
|
|
moduleReference,
|
|
resolvedFileName
|
|
));
|
|
}
|
|
function typesPackageExists(packageName) {
|
|
return getPackagesMap().has(getTypesPackageName(packageName));
|
|
}
|
|
function packageBundlesTypes(packageName) {
|
|
return !!getPackagesMap().get(packageName);
|
|
}
|
|
function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) {
|
|
if (moduleSymbol == null ? void 0 : moduleSymbol.exports) {
|
|
const exportEquals = resolveSymbol(moduleSymbol.exports.get("export=" /* ExportEquals */), dontResolveAlias);
|
|
const exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol));
|
|
return getMergedSymbol(exported) || moduleSymbol;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getCommonJsExportEquals(exported, moduleSymbol) {
|
|
if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152 /* Alias */) {
|
|
return exported;
|
|
}
|
|
const links = getSymbolLinks(exported);
|
|
if (links.cjsExportMerged) {
|
|
return links.cjsExportMerged;
|
|
}
|
|
const merged = exported.flags & 33554432 /* Transient */ ? exported : cloneSymbol(exported);
|
|
merged.flags = merged.flags | 512 /* ValueModule */;
|
|
if (merged.exports === void 0) {
|
|
merged.exports = createSymbolTable();
|
|
}
|
|
moduleSymbol.exports.forEach((s, name) => {
|
|
if (name === "export=" /* 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;
|
|
}
|
|
function resolveESModuleSymbol(moduleSymbol, referencingLocation, dontResolveAlias, suppressInteropError) {
|
|
var _a2;
|
|
const symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
|
|
if (!dontResolveAlias && symbol) {
|
|
if (!suppressInteropError && !(symbol.flags & (1536 /* Module */ | 3 /* Variable */)) && !getDeclarationOfKind(symbol, 308 /* SourceFile */)) {
|
|
const compilerOptionName = moduleKind >= 5 /* ES2015 */ ? "allowSyntheticDefaultImports" : "esModuleInterop";
|
|
error(referencingLocation, 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;
|
|
}
|
|
const referenceParent = referencingLocation.parent;
|
|
if (isImportDeclaration(referenceParent) && getNamespaceDeclarationNode(referenceParent) || isImportCall(referenceParent)) {
|
|
const reference = isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier;
|
|
const type = getTypeOfSymbol(symbol);
|
|
const defaultOnlyType = getTypeWithSyntheticDefaultOnly(type, symbol, moduleSymbol, reference);
|
|
if (defaultOnlyType) {
|
|
return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent);
|
|
}
|
|
const targetFile = (_a2 = moduleSymbol == null ? void 0 : moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const isEsmCjsRef = targetFile && isESMFormatImportImportingCommonjsFormatFile(getUsageModeForExpression(reference), targetFile.impliedNodeFormat);
|
|
if (getESModuleInterop(compilerOptions) || isEsmCjsRef) {
|
|
let sigs = getSignaturesOfStructuredType(type, 0 /* Call */);
|
|
if (!sigs || !sigs.length) {
|
|
sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
|
|
}
|
|
if (sigs && sigs.length || getPropertyOfType(type, "default" /* Default */, true) || isEsmCjsRef) {
|
|
const moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
|
|
return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return symbol;
|
|
}
|
|
function cloneTypeAsModuleType(symbol, moduleType, referenceParent) {
|
|
const 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 Map(symbol.members);
|
|
if (symbol.exports)
|
|
result.exports = new Map(symbol.exports);
|
|
const resolvedModuleType = resolveStructuredTypeMembers(moduleType);
|
|
result.type = createAnonymousType(result, resolvedModuleType.members, emptyArray, emptyArray, resolvedModuleType.indexInfos);
|
|
return result;
|
|
}
|
|
function hasExportAssignmentSymbol(moduleSymbol) {
|
|
return moduleSymbol.exports.get("export=" /* ExportEquals */) !== void 0;
|
|
}
|
|
function getExportsOfModuleAsArray(moduleSymbol) {
|
|
return symbolsToArray(getExportsOfModule(moduleSymbol));
|
|
}
|
|
function getExportsAndPropertiesOfModule(moduleSymbol) {
|
|
const exports = getExportsOfModuleAsArray(moduleSymbol);
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals !== moduleSymbol) {
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
|
|
addRange(exports, getPropertiesOfType(type));
|
|
}
|
|
}
|
|
return exports;
|
|
}
|
|
function forEachExportAndPropertyOfModule(moduleSymbol, cb) {
|
|
const exports = getExportsOfModule(moduleSymbol);
|
|
exports.forEach((symbol, key) => {
|
|
if (!isReservedMemberName(key)) {
|
|
cb(symbol, key);
|
|
}
|
|
});
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals !== moduleSymbol) {
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
|
|
forEachPropertyOfType(type, (symbol, escapedName) => {
|
|
cb(symbol, escapedName);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function tryGetMemberInModuleExports(memberName, moduleSymbol) {
|
|
const symbolTable = getExportsOfModule(moduleSymbol);
|
|
if (symbolTable) {
|
|
return symbolTable.get(memberName);
|
|
}
|
|
}
|
|
function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) {
|
|
const symbol = tryGetMemberInModuleExports(memberName, moduleSymbol);
|
|
if (symbol) {
|
|
return symbol;
|
|
}
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals === moduleSymbol) {
|
|
return void 0;
|
|
}
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
return shouldTreatPropertiesOfExternalModuleAsExports(type) ? getPropertyOfType(type, memberName) : void 0;
|
|
}
|
|
function shouldTreatPropertiesOfExternalModuleAsExports(resolvedExternalModuleType) {
|
|
return !(resolvedExternalModuleType.flags & 131068 /* Primitive */ || getObjectFlags(resolvedExternalModuleType) & 1 /* Class */ || isArrayType(resolvedExternalModuleType) || isTupleType(resolvedExternalModuleType));
|
|
}
|
|
function getExportsOfSymbol(symbol) {
|
|
return symbol.flags & 6256 /* LateBindingContainer */ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports" /* resolvedExports */) : symbol.flags & 1536 /* Module */ ? getExportsOfModule(symbol) : symbol.exports || emptySymbols;
|
|
}
|
|
function getExportsOfModule(moduleSymbol) {
|
|
const links = getSymbolLinks(moduleSymbol);
|
|
return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol));
|
|
}
|
|
function extendExportSymbols(target, source, lookupTable, exportNode) {
|
|
if (!source)
|
|
return;
|
|
source.forEach((sourceSymbol, id) => {
|
|
if (id === "default" /* Default */)
|
|
return;
|
|
const targetSymbol = target.get(id);
|
|
if (!targetSymbol) {
|
|
target.set(id, sourceSymbol);
|
|
if (lookupTable && exportNode) {
|
|
lookupTable.set(id, {
|
|
specifierText: getTextOfNode(exportNode.moduleSpecifier)
|
|
});
|
|
}
|
|
} else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) {
|
|
const collisionTracker = lookupTable.get(id);
|
|
if (!collisionTracker.exportsWithDuplicate) {
|
|
collisionTracker.exportsWithDuplicate = [exportNode];
|
|
} else {
|
|
collisionTracker.exportsWithDuplicate.push(exportNode);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function getExportsOfModuleWorker(moduleSymbol) {
|
|
const visitedSymbols = [];
|
|
moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
|
|
return visit(moduleSymbol) || emptySymbols;
|
|
function visit(symbol) {
|
|
if (!(symbol && symbol.exports && pushIfUnique(visitedSymbols, symbol))) {
|
|
return;
|
|
}
|
|
const symbols = new Map(symbol.exports);
|
|
const exportStars = symbol.exports.get("__export" /* ExportStar */);
|
|
if (exportStars) {
|
|
const nestedSymbols = createSymbolTable();
|
|
const lookupTable = /* @__PURE__ */ new Map();
|
|
if (exportStars.declarations) {
|
|
for (const node of exportStars.declarations) {
|
|
const resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
const exportedSymbols = visit(resolvedModule);
|
|
extendExportSymbols(
|
|
nestedSymbols,
|
|
exportedSymbols,
|
|
lookupTable,
|
|
node
|
|
);
|
|
}
|
|
}
|
|
lookupTable.forEach(({ exportsWithDuplicate }, id) => {
|
|
if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) {
|
|
return;
|
|
}
|
|
for (const node of exportsWithDuplicate) {
|
|
diagnostics.add(createDiagnosticForNode(
|
|
node,
|
|
Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity,
|
|
lookupTable.get(id).specifierText,
|
|
unescapeLeadingUnderscores(id)
|
|
));
|
|
}
|
|
});
|
|
extendExportSymbols(symbols, nestedSymbols);
|
|
}
|
|
return symbols;
|
|
}
|
|
}
|
|
function getMergedSymbol(symbol) {
|
|
let 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) {
|
|
const containingFile = getSourceFileOfNode(enclosingDeclaration);
|
|
const id = getNodeId(containingFile);
|
|
const links = getSymbolLinks(symbol);
|
|
let results;
|
|
if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
|
|
return results;
|
|
}
|
|
if (containingFile && containingFile.imports) {
|
|
for (const importRef of containingFile.imports) {
|
|
if (nodeIsSynthesized(importRef))
|
|
continue;
|
|
const resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, true);
|
|
if (!resolvedModule)
|
|
continue;
|
|
const ref = getAliasForSymbolInContainer(resolvedModule, symbol);
|
|
if (!ref)
|
|
continue;
|
|
results = append(results, resolvedModule);
|
|
}
|
|
if (length(results)) {
|
|
(links.extendedContainersByFile || (links.extendedContainersByFile = /* @__PURE__ */ new Map())).set(id, results);
|
|
return results;
|
|
}
|
|
}
|
|
if (links.extendedContainers) {
|
|
return links.extendedContainers;
|
|
}
|
|
const otherFiles = host.getSourceFiles();
|
|
for (const file of otherFiles) {
|
|
if (!isExternalModule(file))
|
|
continue;
|
|
const sym = getSymbolOfNode(file);
|
|
const ref = getAliasForSymbolInContainer(sym, symbol);
|
|
if (!ref)
|
|
continue;
|
|
results = append(results, sym);
|
|
}
|
|
return links.extendedContainers = results || emptyArray;
|
|
}
|
|
function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
|
|
const container = getParentOfSymbol(symbol);
|
|
if (container && !(symbol.flags & 262144 /* TypeParameter */)) {
|
|
const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
|
|
const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
|
|
const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
|
|
if (enclosingDeclaration && container.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(container, enclosingDeclaration, 1920 /* Namespace */, false)) {
|
|
return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
|
|
}
|
|
const firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) && container.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
|
|
return forEachEntry(t, (s) => {
|
|
if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) {
|
|
return s;
|
|
}
|
|
});
|
|
}) : void 0;
|
|
let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container] : [...additionalContainers, container];
|
|
res = append(res, objectLiteralContainer);
|
|
res = addRange(res, reexportContainers);
|
|
return res;
|
|
}
|
|
const candidates = mapDefined(symbol.declarations, (d) => {
|
|
if (!isAmbientModule(d) && d.parent) {
|
|
if (hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
|
|
return getSymbolOfNode(d.parent);
|
|
}
|
|
if (isModuleBlock(d.parent) && d.parent.parent && resolveExternalModuleSymbol(getSymbolOfNode(d.parent.parent)) === symbol) {
|
|
return getSymbolOfNode(d.parent.parent);
|
|
}
|
|
}
|
|
if (isClassExpression(d) && isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 63 /* EqualsToken */ && isAccessExpression(d.parent.left) && isEntityNameExpression(d.parent.left.expression)) {
|
|
if (isModuleExportsAccessExpression(d.parent.left) || isExportsIdentifier(d.parent.left.expression)) {
|
|
return getSymbolOfNode(getSourceFileOfNode(d));
|
|
}
|
|
checkExpressionCached(d.parent.left.expression);
|
|
return getNodeLinks(d.parent.left.expression).resolvedSymbol;
|
|
}
|
|
});
|
|
if (!length(candidates)) {
|
|
return void 0;
|
|
}
|
|
return mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
|
|
function fileSymbolIfFileSymbolExportEqualsContainer(d) {
|
|
return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
|
|
}
|
|
}
|
|
function getVariableDeclarationOfObjectLiteral(symbol, meaning) {
|
|
const firstDecl = !!length(symbol.declarations) && first(symbol.declarations);
|
|
if (meaning & 111551 /* Value */ && firstDecl && firstDecl.parent && isVariableDeclaration(firstDecl.parent)) {
|
|
if (isObjectLiteralExpression(firstDecl) && firstDecl === firstDecl.parent.initializer || isTypeLiteralNode(firstDecl) && firstDecl === firstDecl.parent.type) {
|
|
return getSymbolOfNode(firstDecl.parent);
|
|
}
|
|
}
|
|
}
|
|
function getFileSymbolIfFileSymbolExportEqualsContainer(d, container) {
|
|
const fileSymbol = getExternalModuleContainer(d);
|
|
const exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export=" /* ExportEquals */);
|
|
return exported && getSymbolIfSameReference(exported, container) ? fileSymbol : void 0;
|
|
}
|
|
function getAliasForSymbolInContainer(container, symbol) {
|
|
if (container === getParentOfSymbol(symbol)) {
|
|
return symbol;
|
|
}
|
|
const exportEquals = container.exports && container.exports.get("export=" /* ExportEquals */);
|
|
if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) {
|
|
return container;
|
|
}
|
|
const exports = getExportsOfSymbol(container);
|
|
const quick = exports.get(symbol.escapedName);
|
|
if (quick && getSymbolIfSameReference(quick, symbol)) {
|
|
return quick;
|
|
}
|
|
return forEachEntry(exports, (exported) => {
|
|
if (getSymbolIfSameReference(exported, symbol)) {
|
|
return exported;
|
|
}
|
|
});
|
|
}
|
|
function getSymbolIfSameReference(s1, s2) {
|
|
if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
|
|
return s1;
|
|
}
|
|
}
|
|
function getExportSymbolOfValueSymbolIfExported(symbol) {
|
|
return getMergedSymbol(symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0 && symbol.exportSymbol || symbol);
|
|
}
|
|
function symbolIsValue(symbol, includeTypeOnlyMembers) {
|
|
return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && getAllSymbolFlags(symbol) & 111551 /* Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
|
|
}
|
|
function findConstructorDeclaration(node) {
|
|
const members = node.members;
|
|
for (const member of members) {
|
|
if (member.kind === 173 /* Constructor */ && nodeIsPresent(member.body)) {
|
|
return member;
|
|
}
|
|
}
|
|
}
|
|
function createType(flags) {
|
|
var _a2;
|
|
const result = new Type7(checker, flags);
|
|
typeCount++;
|
|
result.id = typeCount;
|
|
(_a2 = tracing) == null ? void 0 : _a2.recordType(result);
|
|
return result;
|
|
}
|
|
function createTypeWithSymbol(flags, symbol) {
|
|
const result = createType(flags);
|
|
result.symbol = symbol;
|
|
return result;
|
|
}
|
|
function createOriginType(flags) {
|
|
return new Type7(checker, flags);
|
|
}
|
|
function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */) {
|
|
const type = createType(kind);
|
|
type.intrinsicName = intrinsicName;
|
|
type.objectFlags = objectFlags;
|
|
return type;
|
|
}
|
|
function createObjectType(objectFlags, symbol) {
|
|
const type = createTypeWithSymbol(524288 /* Object */, symbol);
|
|
type.objectFlags = objectFlags;
|
|
type.members = void 0;
|
|
type.properties = void 0;
|
|
type.callSignatures = void 0;
|
|
type.constructSignatures = void 0;
|
|
type.indexInfos = void 0;
|
|
return type;
|
|
}
|
|
function createTypeofType() {
|
|
return getUnionType(arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
|
|
}
|
|
function createTypeParameter(symbol) {
|
|
return createTypeWithSymbol(262144 /* TypeParameter */, symbol);
|
|
}
|
|
function isReservedMemberName(name) {
|
|
return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) !== 95 /* _ */ && name.charCodeAt(2) !== 64 /* at */ && name.charCodeAt(2) !== 35 /* hash */;
|
|
}
|
|
function getNamedMembers(members) {
|
|
let result;
|
|
members.forEach((symbol, id) => {
|
|
if (isNamedMember(symbol, id)) {
|
|
(result || (result = [])).push(symbol);
|
|
}
|
|
});
|
|
return result || emptyArray;
|
|
}
|
|
function isNamedMember(member, escapedName) {
|
|
return !isReservedMemberName(escapedName) && symbolIsValue(member);
|
|
}
|
|
function getNamedOrIndexSignatureMembers(members) {
|
|
const result = getNamedMembers(members);
|
|
const index = getIndexSymbolFromSymbolTable(members);
|
|
return index ? concatenate(result, [index]) : result;
|
|
}
|
|
function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos) {
|
|
const resolved = type;
|
|
resolved.members = members;
|
|
resolved.properties = emptyArray;
|
|
resolved.callSignatures = callSignatures;
|
|
resolved.constructSignatures = constructSignatures;
|
|
resolved.indexInfos = indexInfos;
|
|
if (members !== emptySymbols)
|
|
resolved.properties = getNamedMembers(members);
|
|
return resolved;
|
|
}
|
|
function createAnonymousType(symbol, members, callSignatures, constructSignatures, indexInfos) {
|
|
return setStructuredTypeMembers(
|
|
createObjectType(16 /* Anonymous */, symbol),
|
|
members,
|
|
callSignatures,
|
|
constructSignatures,
|
|
indexInfos
|
|
);
|
|
}
|
|
function getResolvedTypeWithoutAbstractConstructSignatures(type) {
|
|
if (type.constructSignatures.length === 0)
|
|
return type;
|
|
if (type.objectTypeWithoutAbstractConstructSignatures)
|
|
return type.objectTypeWithoutAbstractConstructSignatures;
|
|
const constructSignatures = filter(type.constructSignatures, (signature) => !(signature.flags & 4 /* Abstract */));
|
|
if (type.constructSignatures === constructSignatures)
|
|
return type;
|
|
const typeCopy = createAnonymousType(
|
|
type.symbol,
|
|
type.members,
|
|
type.callSignatures,
|
|
some(constructSignatures) ? constructSignatures : emptyArray,
|
|
type.indexInfos
|
|
);
|
|
type.objectTypeWithoutAbstractConstructSignatures = typeCopy;
|
|
typeCopy.objectTypeWithoutAbstractConstructSignatures = typeCopy;
|
|
return typeCopy;
|
|
}
|
|
function forEachSymbolTableInScope(enclosingDeclaration, callback) {
|
|
let result;
|
|
for (let location = enclosingDeclaration; location; location = location.parent) {
|
|
if (location.locals && !isGlobalSourceFile(location)) {
|
|
if (result = callback(location.locals, void 0, true, location)) {
|
|
return result;
|
|
}
|
|
}
|
|
switch (location.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalOrCommonJsModule(location)) {
|
|
break;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
const sym = getSymbolOfNode(location);
|
|
if (result = callback((sym == null ? void 0 : sym.exports) || emptySymbols, void 0, true, location)) {
|
|
return result;
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
let table;
|
|
(getSymbolOfNode(location).members || emptySymbols).forEach((memberSymbol, key) => {
|
|
if (memberSymbol.flags & (788968 /* Type */ & ~67108864 /* Assignment */)) {
|
|
(table || (table = createSymbolTable())).set(key, memberSymbol);
|
|
}
|
|
});
|
|
if (table && (result = callback(table, void 0, false, location))) {
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return callback(globals, void 0, true);
|
|
}
|
|
function getQualifiedLeftMeaning(rightMeaning) {
|
|
return rightMeaning === 111551 /* Value */ ? 111551 /* Value */ : 1920 /* Namespace */;
|
|
}
|
|
function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap = /* @__PURE__ */ new Map()) {
|
|
if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
|
|
return void 0;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
|
|
const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node);
|
|
const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`;
|
|
if (cache.has(key)) {
|
|
return cache.get(key);
|
|
}
|
|
const id = getSymbolId(symbol);
|
|
let visitedSymbolTables = visitedSymbolTablesMap.get(id);
|
|
if (!visitedSymbolTables) {
|
|
visitedSymbolTablesMap.set(id, visitedSymbolTables = []);
|
|
}
|
|
const result = forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
|
|
cache.set(key, result);
|
|
return result;
|
|
function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification, isLocalNameLookup) {
|
|
if (!pushIfUnique(visitedSymbolTables, symbols)) {
|
|
return void 0;
|
|
}
|
|
const result2 = trySymbolTable(symbols, ignoreQualification, isLocalNameLookup);
|
|
visitedSymbolTables.pop();
|
|
return result2;
|
|
}
|
|
function canQualifySymbol(symbolFromSymbolTable, meaning2) {
|
|
return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning2) || !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning2), useOnlyExternalAliasing, visitedSymbolTablesMap);
|
|
}
|
|
function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) {
|
|
return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) && !some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) && (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning));
|
|
}
|
|
function trySymbolTable(symbols, ignoreQualification, isLocalNameLookup) {
|
|
if (isAccessible(symbols.get(symbol.escapedName), void 0, ignoreQualification)) {
|
|
return [symbol];
|
|
}
|
|
const result2 = forEachEntry(symbols, (symbolFromSymbolTable) => {
|
|
if (symbolFromSymbolTable.flags & 2097152 /* Alias */ && symbolFromSymbolTable.escapedName !== "export=" /* ExportEquals */ && symbolFromSymbolTable.escapedName !== "default" /* Default */ && !(isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && isExternalModule(getSourceFileOfNode(enclosingDeclaration))) && (!useOnlyExternalAliasing || some(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) && (isLocalNameLookup ? !some(symbolFromSymbolTable.declarations, isNamespaceReexportDeclaration) : true) && (ignoreQualification || !getDeclarationOfKind(symbolFromSymbolTable, 278 /* ExportSpecifier */))) {
|
|
const resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
|
|
const candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification);
|
|
if (candidate) {
|
|
return candidate;
|
|
}
|
|
}
|
|
if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) {
|
|
if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), void 0, ignoreQualification)) {
|
|
return [symbol];
|
|
}
|
|
}
|
|
});
|
|
return result2 || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : void 0);
|
|
}
|
|
function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) {
|
|
if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
|
|
return [symbolFromSymbolTable];
|
|
}
|
|
const candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
|
|
const accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, true);
|
|
if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
|
|
return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
|
|
}
|
|
}
|
|
}
|
|
function needsQualification(symbol, enclosingDeclaration, meaning) {
|
|
let qualify = false;
|
|
forEachSymbolTableInScope(enclosingDeclaration, (symbolTable) => {
|
|
let symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName));
|
|
if (!symbolFromSymbolTable) {
|
|
return false;
|
|
}
|
|
if (symbolFromSymbolTable === symbol) {
|
|
return true;
|
|
}
|
|
const shouldResolveAlias = symbolFromSymbolTable.flags & 2097152 /* Alias */ && !getDeclarationOfKind(symbolFromSymbolTable, 278 /* ExportSpecifier */);
|
|
symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
|
|
const flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
|
|
if (flags & meaning) {
|
|
qualify = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
return qualify;
|
|
}
|
|
function isPropertyOrMethodDeclarationSymbol(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length) {
|
|
for (const declaration of symbol.declarations) {
|
|
switch (declaration.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
continue;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 788968 /* Type */, false, true);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 111551 /* Value */, false, true);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isSymbolAccessibleByFlags(typeSymbol, enclosingDeclaration, flags) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, flags, false, false);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
|
|
if (!length(symbols))
|
|
return;
|
|
let hadAccessibleChain;
|
|
let earlyModuleBail = false;
|
|
for (const symbol of symbols) {
|
|
const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, false);
|
|
if (accessibleSymbolChain) {
|
|
hadAccessibleChain = symbol;
|
|
const hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
|
|
if (hasAccessibleDeclarations) {
|
|
return hasAccessibleDeclarations;
|
|
}
|
|
}
|
|
if (allowModules) {
|
|
if (some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
if (shouldComputeAliasesToMakeVisible) {
|
|
earlyModuleBail = true;
|
|
continue;
|
|
}
|
|
return {
|
|
accessibility: 0 /* Accessible */
|
|
};
|
|
}
|
|
}
|
|
const containers = getContainersOfSymbol(symbol, enclosingDeclaration, meaning);
|
|
const parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible, allowModules);
|
|
if (parentResult) {
|
|
return parentResult;
|
|
}
|
|
}
|
|
if (earlyModuleBail) {
|
|
return {
|
|
accessibility: 0 /* Accessible */
|
|
};
|
|
}
|
|
if (hadAccessibleChain) {
|
|
return {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
|
|
errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920 /* Namespace */) : void 0
|
|
};
|
|
}
|
|
}
|
|
function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
|
|
return isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, true);
|
|
}
|
|
function isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
|
|
if (symbol && enclosingDeclaration) {
|
|
const result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible, allowModules);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
const symbolExternalModule = forEach(symbol.declarations, getExternalModuleContainer);
|
|
if (symbolExternalModule) {
|
|
const enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
|
|
if (symbolExternalModule !== enclosingExternalModule) {
|
|
return {
|
|
accessibility: 2 /* CannotBeNamed */,
|
|
errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
|
|
errorModuleName: symbolToString(symbolExternalModule),
|
|
errorNode: isInJSFile(enclosingDeclaration) ? enclosingDeclaration : void 0
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning)
|
|
};
|
|
}
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
function getExternalModuleContainer(declaration) {
|
|
const node = findAncestor(declaration, hasExternalModuleSymbol);
|
|
return node && getSymbolOfNode(node);
|
|
}
|
|
function hasExternalModuleSymbol(declaration) {
|
|
return isAmbientModule(declaration) || declaration.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(declaration);
|
|
}
|
|
function hasNonGlobalAugmentationExternalModuleSymbol(declaration) {
|
|
return isModuleWithStringLiteralName(declaration) || declaration.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(declaration);
|
|
}
|
|
function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
|
|
let aliasesToMakeVisible;
|
|
if (!every(filter(symbol.declarations, (d) => d.kind !== 79 /* Identifier */), getIsDeclarationVisible)) {
|
|
return void 0;
|
|
}
|
|
return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
|
|
function getIsDeclarationVisible(declaration) {
|
|
var _a2, _b;
|
|
if (!isDeclarationVisible(declaration)) {
|
|
const anyImportSyntax = getAnyImportSyntax(declaration);
|
|
if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 1 /* Export */) && isDeclarationVisible(anyImportSyntax.parent)) {
|
|
return addVisibleAlias(declaration, anyImportSyntax);
|
|
} else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 1 /* Export */) && isDeclarationVisible(declaration.parent.parent.parent)) {
|
|
return addVisibleAlias(declaration, declaration.parent.parent);
|
|
} else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 1 /* Export */) && isDeclarationVisible(declaration.parent)) {
|
|
return addVisibleAlias(declaration, declaration);
|
|
} else if (isBindingElement(declaration)) {
|
|
if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a2 = declaration.parent) == null ? void 0 : _a2.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
|
|
return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
|
|
} else if (symbol.flags & 2 /* BlockScopedVariable */) {
|
|
const variableStatement = findAncestor(declaration, isVariableStatement);
|
|
if (hasSyntacticModifier(variableStatement, 1 /* Export */)) {
|
|
return true;
|
|
}
|
|
if (!isDeclarationVisible(variableStatement.parent)) {
|
|
return false;
|
|
}
|
|
return addVisibleAlias(declaration, variableStatement);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function addVisibleAlias(declaration, aliasingStatement) {
|
|
if (shouldComputeAliasToMakeVisible) {
|
|
getNodeLinks(declaration).isVisible = true;
|
|
aliasesToMakeVisible = appendIfUnique(aliasesToMakeVisible, aliasingStatement);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function isEntityNameVisible(entityName, enclosingDeclaration) {
|
|
let meaning;
|
|
if (entityName.parent.kind === 183 /* TypeQuery */ || entityName.parent.kind === 230 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 164 /* ComputedPropertyName */) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
} else if (entityName.kind === 163 /* QualifiedName */ || entityName.kind === 208 /* PropertyAccessExpression */ || entityName.parent.kind === 268 /* ImportEqualsDeclaration */) {
|
|
meaning = 1920 /* Namespace */;
|
|
} else {
|
|
meaning = 788968 /* Type */;
|
|
}
|
|
const firstIdentifier = getFirstIdentifier(entityName);
|
|
const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, void 0, void 0, false);
|
|
if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
if (!symbol && isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(getThisContainer(firstIdentifier, false)), firstIdentifier, meaning, false).accessibility === 0 /* Accessible */) {
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
return symbol && hasVisibleDeclarations(symbol, true) || {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: getTextOfNode(firstIdentifier),
|
|
errorNode: firstIdentifier
|
|
};
|
|
}
|
|
function symbolToString(symbol, enclosingDeclaration, meaning, flags = 4 /* AllowAnyNodeKind */, writer) {
|
|
let nodeFlags = 70221824 /* IgnoreErrors */;
|
|
if (flags & 2 /* UseOnlyExternalAliasing */) {
|
|
nodeFlags |= 128 /* UseOnlyExternalAliasing */;
|
|
}
|
|
if (flags & 1 /* WriteTypeParametersOrArguments */) {
|
|
nodeFlags |= 512 /* WriteTypeParametersInQualifiedName */;
|
|
}
|
|
if (flags & 8 /* UseAliasDefinedOutsideCurrentScope */) {
|
|
nodeFlags |= 16384 /* UseAliasDefinedOutsideCurrentScope */;
|
|
}
|
|
if (flags & 32 /* DoNotIncludeSymbolChain */) {
|
|
nodeFlags |= 134217728 /* DoNotIncludeSymbolChain */;
|
|
}
|
|
if (flags & 16 /* WriteComputedProps */) {
|
|
nodeFlags |= 1073741824 /* WriteComputedProps */;
|
|
}
|
|
const builder = flags & 4 /* AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName;
|
|
return writer ? symbolToStringWorker(writer).getText() : usingSingleLineStringWriter(symbolToStringWorker);
|
|
function symbolToStringWorker(writer2) {
|
|
const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
|
|
const printer = (enclosingDeclaration == null ? void 0 : enclosingDeclaration.kind) === 308 /* SourceFile */ ? createPrinter({ removeComments: true, neverAsciiEscape: true }) : createPrinter({ removeComments: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, entity, sourceFile, writer2);
|
|
return writer2;
|
|
}
|
|
}
|
|
function signatureToString(signature, enclosingDeclaration, flags = 0 /* None */, kind, writer) {
|
|
return writer ? signatureToStringWorker(writer).getText() : usingSingleLineStringWriter(signatureToStringWorker);
|
|
function signatureToStringWorker(writer2) {
|
|
let sigOutput;
|
|
if (flags & 262144 /* WriteArrowStyleSignature */) {
|
|
sigOutput = kind === 1 /* Construct */ ? 182 /* ConstructorType */ : 181 /* FunctionType */;
|
|
} else {
|
|
sigOutput = kind === 1 /* Construct */ ? 177 /* ConstructSignature */ : 176 /* CallSignature */;
|
|
}
|
|
const sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */);
|
|
const printer = createPrinter({ removeComments: true, omitTrailingSemicolon: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, sig, sourceFile, getTrailingSemicolonDeferringWriter(writer2));
|
|
return writer2;
|
|
}
|
|
}
|
|
function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
|
|
const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
|
|
const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0), writer);
|
|
if (typeNode === void 0)
|
|
return Debug.fail("should always get typenode");
|
|
const options = { removeComments: type !== unresolvedType };
|
|
const printer = createPrinter(options);
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, typeNode, sourceFile, writer);
|
|
const result = writer.getText();
|
|
const maxLength = noTruncation ? noTruncationMaximumTruncationLength * 2 : defaultMaximumTruncationLength * 2;
|
|
if (maxLength && result && result.length >= maxLength) {
|
|
return result.substr(0, maxLength - "...".length) + "...";
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeNamesForErrorDisplay(left, right) {
|
|
let leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left);
|
|
let 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, void 0, 64 /* UseFullyQualifiedType */);
|
|
}
|
|
function symbolValueDeclarationIsContextSensitive(symbol) {
|
|
return symbol && !!symbol.valueDeclaration && isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
|
|
}
|
|
function toNodeBuilderFlags(flags = 0 /* None */) {
|
|
return flags & 848330091 /* NodeBuilderFlagsMask */;
|
|
}
|
|
function isClassInstanceSide(type) {
|
|
return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
|
|
}
|
|
function createNodeBuilder() {
|
|
return {
|
|
typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
|
|
indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, void 0)),
|
|
signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
|
|
symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToName(symbol, context, meaning, false)),
|
|
symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
|
|
symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
|
|
symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
|
|
typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
|
|
symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
|
|
symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
|
|
};
|
|
function symbolToNode(symbol, context, meaning) {
|
|
if (context.flags & 1073741824 /* WriteComputedProps */) {
|
|
if (symbol.valueDeclaration) {
|
|
const name = getNameOfDeclaration(symbol.valueDeclaration);
|
|
if (name && isComputedPropertyName(name))
|
|
return name;
|
|
}
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType && nameType.flags & (1024 /* EnumLiteral */ | 8192 /* UniqueESSymbol */)) {
|
|
context.enclosingDeclaration = nameType.symbol.valueDeclaration;
|
|
return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, meaning));
|
|
}
|
|
}
|
|
return symbolToExpression(symbol, context, meaning);
|
|
}
|
|
function withContext(enclosingDeclaration, flags, tracker, cb) {
|
|
var _a2, _b;
|
|
Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 8 /* Synthesized */) === 0);
|
|
const context = {
|
|
enclosingDeclaration,
|
|
flags: flags || 0 /* None */,
|
|
tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: () => false, moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
|
|
getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
getSymlinkCache: maybeBind(host, host.getSymlinkCache),
|
|
getPackageJsonInfoCache: () => {
|
|
var _a3;
|
|
return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
|
|
},
|
|
useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
|
|
redirectTargetsMap: host.redirectTargetsMap,
|
|
getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
|
|
isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
|
|
fileExists: (fileName) => host.fileExists(fileName),
|
|
getFileIncludeReasons: () => host.getFileIncludeReasons(),
|
|
readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
|
|
} : void 0 },
|
|
encounteredError: false,
|
|
reportedDiagnostic: false,
|
|
visitedTypes: void 0,
|
|
symbolDepth: void 0,
|
|
inferTypeParameters: void 0,
|
|
approximateLength: 0
|
|
};
|
|
context.tracker = wrapSymbolTrackerToReportForContext(context, context.tracker);
|
|
const resultingNode = cb(context);
|
|
if (context.truncating && context.flags & 1 /* NoTruncation */) {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.reportTruncationError) == null ? void 0 : _b.call(_a2);
|
|
}
|
|
return context.encounteredError ? void 0 : resultingNode;
|
|
}
|
|
function wrapSymbolTrackerToReportForContext(context, tracker) {
|
|
const oldTrackSymbol = tracker.trackSymbol;
|
|
return {
|
|
...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 && ((...args) => {
|
|
const result = oldTrackSymbol(...args);
|
|
if (result) {
|
|
context.reportedDiagnostic = true;
|
|
}
|
|
return result;
|
|
})
|
|
};
|
|
function wrapReportedDiagnostic(method) {
|
|
if (!method) {
|
|
return method;
|
|
}
|
|
return (...args) => {
|
|
context.reportedDiagnostic = true;
|
|
return method(...args);
|
|
};
|
|
}
|
|
}
|
|
function checkTruncationLength(context) {
|
|
if (context.truncating)
|
|
return context.truncating;
|
|
return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
|
|
}
|
|
function typeToTypeNodeHelper(type, context) {
|
|
const savedFlags = context.flags;
|
|
const typeNode = typeToTypeNodeWorker(type, context);
|
|
context.flags = savedFlags;
|
|
return typeNode;
|
|
}
|
|
function typeToTypeNodeWorker(type, context) {
|
|
if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
const inTypeAlias = context.flags & 8388608 /* InTypeAlias */;
|
|
context.flags &= ~8388608 /* InTypeAlias */;
|
|
if (!type) {
|
|
if (!(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) {
|
|
context.encounteredError = true;
|
|
return void 0;
|
|
}
|
|
context.approximateLength += 3;
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (!(context.flags & 536870912 /* NoTypeReduction */)) {
|
|
type = getReducedType(type);
|
|
}
|
|
if (type.flags & 1 /* Any */) {
|
|
if (type.aliasSymbol) {
|
|
return factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context));
|
|
}
|
|
if (type === unresolvedType) {
|
|
return addSyntheticLeadingComment(factory.createKeywordTypeNode(131 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "unresolved");
|
|
}
|
|
context.approximateLength += 3;
|
|
return factory.createKeywordTypeNode(type === intrinsicMarkerType ? 139 /* IntrinsicKeyword */ : 131 /* AnyKeyword */);
|
|
}
|
|
if (type.flags & 2 /* Unknown */) {
|
|
return factory.createKeywordTypeNode(157 /* UnknownKeyword */);
|
|
}
|
|
if (type.flags & 4 /* String */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(152 /* StringKeyword */);
|
|
}
|
|
if (type.flags & 8 /* Number */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(148 /* NumberKeyword */);
|
|
}
|
|
if (type.flags & 64 /* BigInt */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(160 /* BigIntKeyword */);
|
|
}
|
|
if (type.flags & 16 /* Boolean */ && !type.aliasSymbol) {
|
|
context.approximateLength += 7;
|
|
return factory.createKeywordTypeNode(134 /* BooleanKeyword */);
|
|
}
|
|
if (type.flags & 1056 /* EnumLike */) {
|
|
if (type.symbol.flags & 8 /* EnumMember */) {
|
|
const parentSymbol = getParentOfSymbol(type.symbol);
|
|
const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
|
|
if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
|
|
return parentName;
|
|
}
|
|
const memberName = symbolName(type.symbol);
|
|
if (isIdentifierText(memberName, 0 /* ES3 */)) {
|
|
return appendReferenceToType(
|
|
parentName,
|
|
factory.createTypeReferenceNode(memberName, void 0)
|
|
);
|
|
}
|
|
if (isImportTypeNode(parentName)) {
|
|
parentName.isTypeOf = true;
|
|
return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
|
|
} else if (isTypeReferenceNode(parentName)) {
|
|
return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
|
|
} else {
|
|
return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
|
|
}
|
|
}
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
|
|
}
|
|
if (type.flags & 128 /* StringLiteral */) {
|
|
context.approximateLength += type.value.length + 2;
|
|
return factory.createLiteralTypeNode(setEmitFlags(factory.createStringLiteral(type.value, !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */)), 33554432 /* NoAsciiEscaping */));
|
|
}
|
|
if (type.flags & 256 /* NumberLiteral */) {
|
|
const value = type.value;
|
|
context.approximateLength += ("" + value).length;
|
|
return factory.createLiteralTypeNode(value < 0 ? factory.createPrefixUnaryExpression(40 /* MinusToken */, factory.createNumericLiteral(-value)) : factory.createNumericLiteral(value));
|
|
}
|
|
if (type.flags & 2048 /* BigIntLiteral */) {
|
|
context.approximateLength += pseudoBigIntToString(type.value).length + 1;
|
|
return factory.createLiteralTypeNode(factory.createBigIntLiteral(type.value));
|
|
}
|
|
if (type.flags & 512 /* BooleanLiteral */) {
|
|
context.approximateLength += type.intrinsicName.length;
|
|
return factory.createLiteralTypeNode(type.intrinsicName === "true" ? factory.createTrue() : factory.createFalse());
|
|
}
|
|
if (type.flags & 8192 /* UniqueESSymbol */) {
|
|
if (!(context.flags & 1048576 /* AllowUniqueESSymbolType */)) {
|
|
if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
|
|
context.approximateLength += 6;
|
|
return symbolToTypeNode(type.symbol, context, 111551 /* Value */);
|
|
}
|
|
if (context.tracker.reportInaccessibleUniqueSymbolError) {
|
|
context.tracker.reportInaccessibleUniqueSymbolError();
|
|
}
|
|
}
|
|
context.approximateLength += 13;
|
|
return factory.createTypeOperatorNode(156 /* UniqueKeyword */, factory.createKeywordTypeNode(153 /* SymbolKeyword */));
|
|
}
|
|
if (type.flags & 16384 /* Void */) {
|
|
context.approximateLength += 4;
|
|
return factory.createKeywordTypeNode(114 /* VoidKeyword */);
|
|
}
|
|
if (type.flags & 32768 /* Undefined */) {
|
|
context.approximateLength += 9;
|
|
return factory.createKeywordTypeNode(155 /* UndefinedKeyword */);
|
|
}
|
|
if (type.flags & 65536 /* Null */) {
|
|
context.approximateLength += 4;
|
|
return factory.createLiteralTypeNode(factory.createNull());
|
|
}
|
|
if (type.flags & 131072 /* Never */) {
|
|
context.approximateLength += 5;
|
|
return factory.createKeywordTypeNode(144 /* NeverKeyword */);
|
|
}
|
|
if (type.flags & 4096 /* ESSymbol */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(153 /* SymbolKeyword */);
|
|
}
|
|
if (type.flags & 67108864 /* NonPrimitive */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(149 /* ObjectKeyword */);
|
|
}
|
|
if (isThisTypeParameter(type)) {
|
|
if (context.flags & 4194304 /* InObjectTypeLiteral */) {
|
|
if (!context.encounteredError && !(context.flags & 32768 /* AllowThisInObjectLiteral */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
if (context.tracker.reportInaccessibleThisError) {
|
|
context.tracker.reportInaccessibleThisError();
|
|
}
|
|
}
|
|
context.approximateLength += 4;
|
|
return factory.createThisTypeNode();
|
|
}
|
|
if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
|
|
const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
|
|
if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */))
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
|
|
if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
|
|
return factory.createArrayTypeNode(typeArgumentNodes[0]);
|
|
}
|
|
return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
|
|
}
|
|
const objectFlags = getObjectFlags(type);
|
|
if (objectFlags & 4 /* Reference */) {
|
|
Debug.assert(!!(type.flags & 524288 /* Object */));
|
|
return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
|
|
if (type.flags & 262144 /* TypeParameter */ && contains(context.inferTypeParameters, type)) {
|
|
context.approximateLength += symbolName(type.symbol).length + 6;
|
|
let constraintNode;
|
|
const constraint = getConstraintOfTypeParameter(type);
|
|
if (constraint) {
|
|
const inferredConstraint = getInferredTypeParameterConstraint(type, true);
|
|
if (!(inferredConstraint && isTypeIdenticalTo(constraint, inferredConstraint))) {
|
|
context.approximateLength += 9;
|
|
constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
|
|
}
|
|
}
|
|
return factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, constraintNode));
|
|
}
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
|
|
const name2 = typeParameterToName(type, context);
|
|
context.approximateLength += idText(name2).length;
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(idText(name2)), void 0);
|
|
}
|
|
if (type.symbol) {
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
|
|
}
|
|
const name = (type === markerSuperTypeForCheck || type === markerSubTypeForCheck) && varianceTypeParameter && varianceTypeParameter.symbol ? (type === markerSubTypeForCheck ? "sub-" : "super-") + symbolName(varianceTypeParameter.symbol) : "?";
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(name), void 0);
|
|
}
|
|
if (type.flags & 1048576 /* Union */ && type.origin) {
|
|
type = type.origin;
|
|
}
|
|
if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
|
|
const types = type.flags & 1048576 /* Union */ ? formatUnionTypes(type.types) : type.types;
|
|
if (length(types) === 1) {
|
|
return typeToTypeNodeHelper(types[0], context);
|
|
}
|
|
const typeNodes = mapToTypeNodes(types, context, true);
|
|
if (typeNodes && typeNodes.length > 0) {
|
|
return type.flags & 1048576 /* Union */ ? factory.createUnionTypeNode(typeNodes) : factory.createIntersectionTypeNode(typeNodes);
|
|
} else {
|
|
if (!context.encounteredError && !(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
if (objectFlags & (16 /* Anonymous */ | 32 /* Mapped */)) {
|
|
Debug.assert(!!(type.flags & 524288 /* Object */));
|
|
return createAnonymousTypeNode(type);
|
|
}
|
|
if (type.flags & 4194304 /* Index */) {
|
|
const indexedType = type.type;
|
|
context.approximateLength += 6;
|
|
const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
|
|
return factory.createTypeOperatorNode(141 /* KeyOfKeyword */, indexTypeNode);
|
|
}
|
|
if (type.flags & 134217728 /* TemplateLiteral */) {
|
|
const texts = type.texts;
|
|
const types = type.types;
|
|
const templateHead = factory.createTemplateHead(texts[0]);
|
|
const templateSpans = factory.createNodeArray(
|
|
map(types, (t, i) => factory.createTemplateLiteralTypeSpan(
|
|
typeToTypeNodeHelper(t, context),
|
|
(i < types.length - 1 ? factory.createTemplateMiddle : factory.createTemplateTail)(texts[i + 1])
|
|
))
|
|
);
|
|
context.approximateLength += 2;
|
|
return factory.createTemplateLiteralType(templateHead, templateSpans);
|
|
}
|
|
if (type.flags & 268435456 /* StringMapping */) {
|
|
const typeNode = typeToTypeNodeHelper(type.type, context);
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */, [typeNode]);
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
const objectTypeNode = typeToTypeNodeHelper(type.objectType, context);
|
|
const indexTypeNode = typeToTypeNodeHelper(type.indexType, context);
|
|
context.approximateLength += 2;
|
|
return factory.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
|
|
}
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
return typeToTypeNodeHelper(type.baseType, context);
|
|
}
|
|
return Debug.fail("Should be unreachable.");
|
|
function conditionalTypeToTypeNode(type2) {
|
|
const checkTypeNode = typeToTypeNodeHelper(type2.checkType, context);
|
|
context.approximateLength += 15;
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type2.root.isDistributive && !(type2.checkType.flags & 262144 /* TypeParameter */)) {
|
|
const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
|
|
const name = typeParameterToName(newParam, context);
|
|
const newTypeVariable = factory.createTypeReferenceNode(name);
|
|
context.approximateLength += 37;
|
|
const newMapper = prependTypeMapping(type2.root.checkType, newParam, type2.mapper);
|
|
const saveInferTypeParameters2 = context.inferTypeParameters;
|
|
context.inferTypeParameters = type2.root.inferTypeParameters;
|
|
const extendsTypeNode2 = typeToTypeNodeHelper(instantiateType(type2.root.extendsType, newMapper), context);
|
|
context.inferTypeParameters = saveInferTypeParameters2;
|
|
const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.trueType), newMapper));
|
|
const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.falseType), newMapper));
|
|
return factory.createConditionalTypeNode(
|
|
checkTypeNode,
|
|
factory.createInferTypeNode(factory.createTypeParameterDeclaration(void 0, factory.cloneNode(newTypeVariable.typeName))),
|
|
factory.createConditionalTypeNode(
|
|
factory.createTypeReferenceNode(factory.cloneNode(name)),
|
|
typeToTypeNodeHelper(type2.checkType, context),
|
|
factory.createConditionalTypeNode(newTypeVariable, extendsTypeNode2, trueTypeNode2, falseTypeNode2),
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
),
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
);
|
|
}
|
|
const saveInferTypeParameters = context.inferTypeParameters;
|
|
context.inferTypeParameters = type2.root.inferTypeParameters;
|
|
const extendsTypeNode = typeToTypeNodeHelper(type2.extendsType, context);
|
|
context.inferTypeParameters = saveInferTypeParameters;
|
|
const trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type2));
|
|
const falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type2));
|
|
return factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
|
|
}
|
|
function typeToTypeNodeOrCircularityElision(type2) {
|
|
var _a2, _b, _c;
|
|
if (type2.flags & 1048576 /* Union */) {
|
|
if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(getTypeId(type2))) {
|
|
if (!(context.flags & 131072 /* AllowAnonymousIdentifier */)) {
|
|
context.encounteredError = true;
|
|
(_c = (_b = context.tracker) == null ? void 0 : _b.reportCyclicStructureError) == null ? void 0 : _c.call(_b);
|
|
}
|
|
return createElidedInformationPlaceholder(context);
|
|
}
|
|
return visitAndTransformType(type2, (type3) => typeToTypeNodeHelper(type3, context));
|
|
}
|
|
return typeToTypeNodeHelper(type2, context);
|
|
}
|
|
function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) {
|
|
return isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 262144 /* TypeParameter */);
|
|
}
|
|
function createMappedTypeNodeFromType(type2) {
|
|
Debug.assert(!!(type2.flags & 524288 /* Object */));
|
|
const readonlyToken = type2.declaration.readonlyToken ? factory.createToken(type2.declaration.readonlyToken.kind) : void 0;
|
|
const questionToken = type2.declaration.questionToken ? factory.createToken(type2.declaration.questionToken.kind) : void 0;
|
|
let appropriateConstraintTypeNode;
|
|
let newTypeVariable;
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type2)) {
|
|
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
|
|
const name = typeParameterToName(newParam, context);
|
|
newTypeVariable = factory.createTypeReferenceNode(name);
|
|
}
|
|
appropriateConstraintTypeNode = factory.createTypeOperatorNode(141 /* KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context));
|
|
} else {
|
|
appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type2), context);
|
|
}
|
|
const typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type2), context, appropriateConstraintTypeNode);
|
|
const nameTypeNode = type2.declaration.nameType ? typeToTypeNodeHelper(getNameTypeFromMappedType(type2), context) : void 0;
|
|
const templateTypeNode = typeToTypeNodeHelper(removeMissingType(getTemplateTypeFromMappedType(type2), !!(getMappedTypeModifiers(type2) & 4 /* IncludeOptional */)), context);
|
|
const mappedTypeNode = factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, void 0);
|
|
context.approximateLength += 10;
|
|
const result = setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
|
|
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
|
|
return factory.createConditionalTypeNode(
|
|
typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context),
|
|
factory.createInferTypeNode(factory.createTypeParameterDeclaration(void 0, factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* Unknown */ ? void 0 : typeToTypeNodeHelper(originalConstraint, context))),
|
|
result,
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
function createAnonymousTypeNode(type2) {
|
|
var _a2;
|
|
const typeId = type2.id;
|
|
const symbol = type2.symbol;
|
|
if (symbol) {
|
|
const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
|
|
if (isJSConstructor(symbol.valueDeclaration)) {
|
|
return symbolToTypeNode(symbol, context, isInstanceType);
|
|
} else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(symbol, context.enclosingDeclaration, isInstanceType, false).accessibility !== 0 /* Accessible */)) || symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) || shouldWriteTypeOfFunctionSymbol()) {
|
|
return symbolToTypeNode(symbol, context, isInstanceType);
|
|
} else if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(typeId)) {
|
|
const typeAlias = getTypeAliasForTypeLiteral(type2);
|
|
if (typeAlias) {
|
|
return symbolToTypeNode(typeAlias, context, 788968 /* Type */);
|
|
} else {
|
|
return createElidedInformationPlaceholder(context);
|
|
}
|
|
} else {
|
|
return visitAndTransformType(type2, createTypeNodeFromObjectType);
|
|
}
|
|
} else {
|
|
return createTypeNodeFromObjectType(type2);
|
|
}
|
|
function shouldWriteTypeOfFunctionSymbol() {
|
|
var _a3;
|
|
const isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */) && some(symbol.declarations, (declaration) => isStatic(declaration));
|
|
const isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || forEach(symbol.declarations, (declaration) => declaration.parent.kind === 308 /* SourceFile */ || declaration.parent.kind === 265 /* ModuleBlock */));
|
|
if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
|
|
return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a3 = context.visitedTypes) == null ? void 0 : _a3.has(typeId))) && (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
|
|
}
|
|
}
|
|
}
|
|
function visitAndTransformType(type2, transform) {
|
|
var _a2, _b;
|
|
const typeId = type2.id;
|
|
const isConstructorObject = getObjectFlags(type2) & 16 /* Anonymous */ && type2.symbol && type2.symbol.flags & 32 /* Class */;
|
|
const id = getObjectFlags(type2) & 4 /* Reference */ && type2.node ? "N" + getNodeId(type2.node) : type2.flags & 16777216 /* Conditional */ ? "N" + getNodeId(type2.root.node) : type2.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type2.symbol) : void 0;
|
|
if (!context.visitedTypes) {
|
|
context.visitedTypes = /* @__PURE__ */ new Set();
|
|
}
|
|
if (id && !context.symbolDepth) {
|
|
context.symbolDepth = /* @__PURE__ */ new Map();
|
|
}
|
|
const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
|
|
const key = `${getTypeId(type2)}|${context.flags}`;
|
|
if (links) {
|
|
links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
|
|
}
|
|
const cachedResult = (_a2 = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _a2.get(key);
|
|
if (cachedResult) {
|
|
if (cachedResult.truncating) {
|
|
context.truncating = true;
|
|
}
|
|
context.approximateLength += cachedResult.addedLength;
|
|
return deepCloneOrReuseNode(cachedResult);
|
|
}
|
|
let 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);
|
|
const startLength = context.approximateLength;
|
|
const result = transform(type2);
|
|
const addedLength = context.approximateLength - startLength;
|
|
if (!context.reportedDiagnostic && !context.encounteredError) {
|
|
if (context.truncating) {
|
|
result.truncating = true;
|
|
}
|
|
result.addedLength = addedLength;
|
|
(_b = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _b.set(key, result);
|
|
}
|
|
context.visitedTypes.delete(typeId);
|
|
if (id) {
|
|
context.symbolDepth.set(id, depth);
|
|
}
|
|
return result;
|
|
function deepCloneOrReuseNode(node) {
|
|
if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
|
|
return node;
|
|
}
|
|
return setTextRange(factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, nullTransformationContext, deepCloneOrReuseNodes)), node);
|
|
}
|
|
function deepCloneOrReuseNodes(nodes, visitor, test, start, count) {
|
|
if (nodes && nodes.length === 0) {
|
|
return setTextRange(factory.createNodeArray(void 0, nodes.hasTrailingComma), nodes);
|
|
}
|
|
return visitNodes2(nodes, visitor, test, start, count);
|
|
}
|
|
}
|
|
function createTypeNodeFromObjectType(type2) {
|
|
if (isGenericMappedType(type2) || type2.containsError) {
|
|
return createMappedTypeNodeFromType(type2);
|
|
}
|
|
const resolved = resolveStructuredTypeMembers(type2);
|
|
if (!resolved.properties.length && !resolved.indexInfos.length) {
|
|
if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
|
|
context.approximateLength += 2;
|
|
return setEmitFlags(factory.createTypeLiteralNode(void 0), 1 /* SingleLine */);
|
|
}
|
|
if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
|
|
const signature = resolved.callSignatures[0];
|
|
const signatureNode = signatureToSignatureDeclarationHelper(signature, 181 /* FunctionType */, context);
|
|
return signatureNode;
|
|
}
|
|
if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
|
|
const signature = resolved.constructSignatures[0];
|
|
const signatureNode = signatureToSignatureDeclarationHelper(signature, 182 /* ConstructorType */, context);
|
|
return signatureNode;
|
|
}
|
|
}
|
|
const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
|
|
if (some(abstractSignatures)) {
|
|
const types = map(abstractSignatures, getOrCreateTypeFromSignature);
|
|
const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
|
|
if (typeElementCount) {
|
|
types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved));
|
|
}
|
|
return typeToTypeNodeHelper(getIntersectionType(types), context);
|
|
}
|
|
const savedFlags = context.flags;
|
|
context.flags |= 4194304 /* InObjectTypeLiteral */;
|
|
const members = createTypeNodesFromResolvedType(resolved);
|
|
context.flags = savedFlags;
|
|
const typeLiteralNode = factory.createTypeLiteralNode(members);
|
|
context.approximateLength += 2;
|
|
setEmitFlags(typeLiteralNode, context.flags & 1024 /* MultilineObjectLiterals */ ? 0 : 1 /* SingleLine */);
|
|
return typeLiteralNode;
|
|
}
|
|
function typeReferenceToTypeNode(type2) {
|
|
let typeArguments = getTypeArguments(type2);
|
|
if (type2.target === globalArrayType || type2.target === globalReadonlyArrayType) {
|
|
if (context.flags & 2 /* WriteArrayAsGenericType */) {
|
|
const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);
|
|
return factory.createTypeReferenceNode(type2.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);
|
|
}
|
|
const elementType = typeToTypeNodeHelper(typeArguments[0], context);
|
|
const arrayType = factory.createArrayTypeNode(elementType);
|
|
return type2.target === globalArrayType ? arrayType : factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, arrayType);
|
|
} else if (type2.target.objectFlags & 8 /* Tuple */) {
|
|
typeArguments = sameMap(typeArguments, (t, i) => removeMissingType(t, !!(type2.target.elementFlags[i] & 2 /* Optional */)));
|
|
if (typeArguments.length > 0) {
|
|
const arity = getTypeReferenceArity(type2);
|
|
const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
|
|
if (tupleConstituentNodes) {
|
|
if (type2.target.labeledElementDeclarations) {
|
|
for (let i = 0; i < tupleConstituentNodes.length; i++) {
|
|
const flags = type2.target.elementFlags[i];
|
|
tupleConstituentNodes[i] = factory.createNamedTupleMember(
|
|
flags & 12 /* Variable */ ? factory.createToken(25 /* DotDotDotToken */) : void 0,
|
|
factory.createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel(type2.target.labeledElementDeclarations[i]))),
|
|
flags & 2 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]
|
|
);
|
|
}
|
|
} else {
|
|
for (let i = 0; i < Math.min(arity, tupleConstituentNodes.length); i++) {
|
|
const flags = type2.target.elementFlags[i];
|
|
tupleConstituentNodes[i] = flags & 12 /* Variable */ ? factory.createRestTypeNode(flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) : flags & 2 /* Optional */ ? factory.createOptionalTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i];
|
|
}
|
|
}
|
|
const tupleTypeNode = setEmitFlags(factory.createTupleTypeNode(tupleConstituentNodes), 1 /* SingleLine */);
|
|
return type2.target.readonly ? factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode;
|
|
}
|
|
}
|
|
if (context.encounteredError || context.flags & 524288 /* AllowEmptyTuple */) {
|
|
const tupleTypeNode = setEmitFlags(factory.createTupleTypeNode([]), 1 /* SingleLine */);
|
|
return type2.target.readonly ? factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode;
|
|
}
|
|
context.encounteredError = true;
|
|
return void 0;
|
|
} else if (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && type2.symbol.valueDeclaration && isClassLike(type2.symbol.valueDeclaration) && !isValueSymbolAccessible(type2.symbol, context.enclosingDeclaration)) {
|
|
return createAnonymousTypeNode(type2);
|
|
} else {
|
|
const outerTypeParameters = type2.target.outerTypeParameters;
|
|
let i = 0;
|
|
let resultType;
|
|
if (outerTypeParameters) {
|
|
const length2 = outerTypeParameters.length;
|
|
while (i < length2) {
|
|
const start = i;
|
|
const parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
|
|
do {
|
|
i++;
|
|
} while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
|
|
if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) {
|
|
const typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
|
|
const flags2 = context.flags;
|
|
context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
|
|
const ref = symbolToTypeNode(parent, context, 788968 /* Type */, typeArgumentSlice);
|
|
context.flags = flags2;
|
|
resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
|
|
}
|
|
}
|
|
}
|
|
let typeArgumentNodes;
|
|
if (typeArguments.length > 0) {
|
|
const typeParameterCount = (type2.target.typeParameters || emptyArray).length;
|
|
typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
|
|
}
|
|
const flags = context.flags;
|
|
context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
|
|
const finalRef = symbolToTypeNode(type2.symbol, context, 788968 /* Type */, typeArgumentNodes);
|
|
context.flags = flags;
|
|
return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
|
|
}
|
|
}
|
|
function appendReferenceToType(root, ref) {
|
|
if (isImportTypeNode(root)) {
|
|
let typeArguments = root.typeArguments;
|
|
let qualifier = root.qualifier;
|
|
if (qualifier) {
|
|
if (isIdentifier(qualifier)) {
|
|
qualifier = factory.updateIdentifier(qualifier, typeArguments);
|
|
} else {
|
|
qualifier = factory.updateQualifiedName(
|
|
qualifier,
|
|
qualifier.left,
|
|
factory.updateIdentifier(qualifier.right, typeArguments)
|
|
);
|
|
}
|
|
}
|
|
typeArguments = ref.typeArguments;
|
|
const ids = getAccessStack(ref);
|
|
for (const id of ids) {
|
|
qualifier = qualifier ? factory.createQualifiedName(qualifier, id) : id;
|
|
}
|
|
return factory.updateImportTypeNode(
|
|
root,
|
|
root.argument,
|
|
root.assertions,
|
|
qualifier,
|
|
typeArguments,
|
|
root.isTypeOf
|
|
);
|
|
} else {
|
|
let typeArguments = root.typeArguments;
|
|
let typeName = root.typeName;
|
|
if (isIdentifier(typeName)) {
|
|
typeName = factory.updateIdentifier(typeName, typeArguments);
|
|
} else {
|
|
typeName = factory.updateQualifiedName(
|
|
typeName,
|
|
typeName.left,
|
|
factory.updateIdentifier(typeName.right, typeArguments)
|
|
);
|
|
}
|
|
typeArguments = ref.typeArguments;
|
|
const ids = getAccessStack(ref);
|
|
for (const id of ids) {
|
|
typeName = factory.createQualifiedName(typeName, id);
|
|
}
|
|
return factory.updateTypeReferenceNode(
|
|
root,
|
|
typeName,
|
|
typeArguments
|
|
);
|
|
}
|
|
}
|
|
function getAccessStack(ref) {
|
|
let state = ref.typeName;
|
|
const ids = [];
|
|
while (!isIdentifier(state)) {
|
|
ids.unshift(state.right);
|
|
state = state.left;
|
|
}
|
|
ids.unshift(state);
|
|
return ids;
|
|
}
|
|
function createTypeNodesFromResolvedType(resolvedType) {
|
|
if (checkTruncationLength(context)) {
|
|
return [factory.createPropertySignature(void 0, "...", void 0, void 0)];
|
|
}
|
|
const typeElements = [];
|
|
for (const signature of resolvedType.callSignatures) {
|
|
typeElements.push(signatureToSignatureDeclarationHelper(signature, 176 /* CallSignature */, context));
|
|
}
|
|
for (const signature of resolvedType.constructSignatures) {
|
|
if (signature.flags & 4 /* Abstract */)
|
|
continue;
|
|
typeElements.push(signatureToSignatureDeclarationHelper(signature, 177 /* ConstructSignature */, context));
|
|
}
|
|
for (const info of resolvedType.indexInfos) {
|
|
typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 1024 /* ReverseMapped */ ? createElidedInformationPlaceholder(context) : void 0));
|
|
}
|
|
const properties = resolvedType.properties;
|
|
if (!properties) {
|
|
return typeElements;
|
|
}
|
|
let i = 0;
|
|
for (const propertySymbol of properties) {
|
|
i++;
|
|
if (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */) {
|
|
if (propertySymbol.flags & 4194304 /* Prototype */) {
|
|
continue;
|
|
}
|
|
if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 /* Private */ | 16 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
|
|
context.tracker.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(propertySymbol.escapedName));
|
|
}
|
|
}
|
|
if (checkTruncationLength(context) && i + 2 < properties.length - 1) {
|
|
typeElements.push(factory.createPropertySignature(void 0, `... ${properties.length - i} more ...`, void 0, void 0));
|
|
addPropertyToElementList(properties[properties.length - 1], context, typeElements);
|
|
break;
|
|
}
|
|
addPropertyToElementList(propertySymbol, context, typeElements);
|
|
}
|
|
return typeElements.length ? typeElements : void 0;
|
|
}
|
|
}
|
|
function createElidedInformationPlaceholder(context) {
|
|
context.approximateLength += 3;
|
|
if (!(context.flags & 1 /* NoTruncation */)) {
|
|
return factory.createTypeReferenceNode(factory.createIdentifier("..."), void 0);
|
|
}
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
function shouldUsePlaceholderForProperty(propertySymbol, context) {
|
|
var _a2;
|
|
return !!(getCheckFlags(propertySymbol) & 8192 /* ReverseMapped */) && (contains(context.reverseMappedStack, propertySymbol) || ((_a2 = context.reverseMappedStack) == null ? void 0 : _a2[0]) && !(getObjectFlags(last(context.reverseMappedStack).propertyType) & 16 /* Anonymous */));
|
|
}
|
|
function addPropertyToElementList(propertySymbol, context, typeElements) {
|
|
var _a2, _b;
|
|
const propertyIsReverseMapped = !!(getCheckFlags(propertySymbol) & 8192 /* ReverseMapped */);
|
|
const propertyType = shouldUsePlaceholderForProperty(propertySymbol, context) ? anyType : getNonMissingTypeOfSymbol(propertySymbol);
|
|
const saveEnclosingDeclaration = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = void 0;
|
|
if (context.tracker.trackSymbol && isLateBoundName(propertySymbol.escapedName)) {
|
|
if (propertySymbol.declarations) {
|
|
const decl = first(propertySymbol.declarations);
|
|
if (hasLateBindableName(decl)) {
|
|
if (isBinaryExpression(decl)) {
|
|
const name = getNameOfDeclaration(decl);
|
|
if (name && isElementAccessExpression(name) && isPropertyAccessEntityNameExpression(name.argumentExpression)) {
|
|
trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
|
|
}
|
|
} else {
|
|
trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
|
|
}
|
|
}
|
|
} else if ((_a2 = context.tracker) == null ? void 0 : _a2.reportNonSerializableProperty) {
|
|
context.tracker.reportNonSerializableProperty(symbolToString(propertySymbol));
|
|
}
|
|
}
|
|
context.enclosingDeclaration = propertySymbol.valueDeclaration || ((_b = propertySymbol.declarations) == null ? void 0 : _b[0]) || saveEnclosingDeclaration;
|
|
const propertyName = getPropertyNameNodeForSymbol(propertySymbol, context);
|
|
context.enclosingDeclaration = saveEnclosingDeclaration;
|
|
context.approximateLength += symbolName(propertySymbol).length + 1;
|
|
const optionalToken = propertySymbol.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0;
|
|
if (propertySymbol.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {
|
|
const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */);
|
|
for (const signature of signatures) {
|
|
const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 170 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
|
|
typeElements.push(preserveCommentsOn(methodDeclaration));
|
|
}
|
|
} else {
|
|
let propertyTypeNode;
|
|
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) : factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
if (propertyIsReverseMapped) {
|
|
context.reverseMappedStack.pop();
|
|
}
|
|
}
|
|
const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(146 /* ReadonlyKeyword */)] : void 0;
|
|
if (modifiers) {
|
|
context.approximateLength += 9;
|
|
}
|
|
const propertySignature = factory.createPropertySignature(
|
|
modifiers,
|
|
propertyName,
|
|
optionalToken,
|
|
propertyTypeNode
|
|
);
|
|
typeElements.push(preserveCommentsOn(propertySignature));
|
|
}
|
|
function preserveCommentsOn(node) {
|
|
var _a3;
|
|
if (some(propertySymbol.declarations, (d) => d.kind === 350 /* JSDocPropertyTag */)) {
|
|
const d = (_a3 = propertySymbol.declarations) == null ? void 0 : _a3.find((d2) => d2.kind === 350 /* JSDocPropertyTag */);
|
|
const commentText = getTextOfJSDocComment(d.comment);
|
|
if (commentText) {
|
|
setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
|
|
}
|
|
} else if (propertySymbol.valueDeclaration) {
|
|
setCommentRange(node, propertySymbol.valueDeclaration);
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function mapToTypeNodes(types, context, isBareList) {
|
|
if (some(types)) {
|
|
if (checkTruncationLength(context)) {
|
|
if (!isBareList) {
|
|
return [factory.createTypeReferenceNode("...", void 0)];
|
|
} else if (types.length > 2) {
|
|
return [
|
|
typeToTypeNodeHelper(types[0], context),
|
|
factory.createTypeReferenceNode(`... ${types.length - 2} more ...`, void 0),
|
|
typeToTypeNodeHelper(types[types.length - 1], context)
|
|
];
|
|
}
|
|
}
|
|
const mayHaveNameCollisions = !(context.flags & 64 /* UseFullyQualifiedType */);
|
|
const seenNames = mayHaveNameCollisions ? createUnderscoreEscapedMultiMap() : void 0;
|
|
const result = [];
|
|
let i = 0;
|
|
for (const type of types) {
|
|
i++;
|
|
if (checkTruncationLength(context) && i + 2 < types.length - 1) {
|
|
result.push(factory.createTypeReferenceNode(`... ${types.length - i} more ...`, void 0));
|
|
const typeNode2 = typeToTypeNodeHelper(types[types.length - 1], context);
|
|
if (typeNode2) {
|
|
result.push(typeNode2);
|
|
}
|
|
break;
|
|
}
|
|
context.approximateLength += 2;
|
|
const typeNode = typeToTypeNodeHelper(type, context);
|
|
if (typeNode) {
|
|
result.push(typeNode);
|
|
if (seenNames && isIdentifierTypeReference(typeNode)) {
|
|
seenNames.add(typeNode.typeName.escapedText, [type, result.length - 1]);
|
|
}
|
|
}
|
|
}
|
|
if (seenNames) {
|
|
const saveContextFlags = context.flags;
|
|
context.flags |= 64 /* UseFullyQualifiedType */;
|
|
seenNames.forEach((types2) => {
|
|
if (!arrayIsHomogeneous(types2, ([a], [b]) => typesAreSameReference(a, b))) {
|
|
for (const [type, resultIndex] of types2) {
|
|
result[resultIndex] = typeToTypeNodeHelper(type, context);
|
|
}
|
|
}
|
|
});
|
|
context.flags = saveContextFlags;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function typesAreSameReference(a, b) {
|
|
return a === b || !!a.symbol && a.symbol === b.symbol || !!a.aliasSymbol && a.aliasSymbol === b.aliasSymbol;
|
|
}
|
|
function indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, typeNode) {
|
|
const name = getNameFromIndexInfo(indexInfo) || "x";
|
|
const indexerTypeNode = typeToTypeNodeHelper(indexInfo.keyType, context);
|
|
const indexingParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
indexerTypeNode,
|
|
void 0
|
|
);
|
|
if (!typeNode) {
|
|
typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context);
|
|
}
|
|
if (!indexInfo.type && !(context.flags & 2097152 /* AllowEmptyIndexInfoType */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
context.approximateLength += name.length + 4;
|
|
return factory.createIndexSignature(
|
|
indexInfo.isReadonly ? [factory.createToken(146 /* ReadonlyKeyword */)] : void 0,
|
|
[indexingParameter],
|
|
typeNode
|
|
);
|
|
}
|
|
function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
|
|
var _a2, _b, _c, _d;
|
|
const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
|
|
if (suppressAny)
|
|
context.flags &= ~256 /* SuppressAnyReturnType */;
|
|
context.approximateLength += 3;
|
|
let typeParameters;
|
|
let typeArguments;
|
|
if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
|
|
typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
|
|
} else {
|
|
typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
|
|
}
|
|
const expandedParams = getExpandedParameters(signature, true)[0];
|
|
const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 173 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
|
|
const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
|
|
if (thisParameter) {
|
|
parameters.unshift(thisParameter);
|
|
}
|
|
let returnTypeNode;
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (typePredicate) {
|
|
const assertsModifier = typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(129 /* AssertsKeyword */) : void 0;
|
|
const parameterName = typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? setEmitFlags(factory.createIdentifier(typePredicate.parameterName), 33554432 /* NoAsciiEscaping */) : factory.createThisTypeNode();
|
|
const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
|
|
returnTypeNode = factory.createTypePredicateNode(assertsModifier, parameterName, typeNode);
|
|
} else {
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType && !(suppressAny && isTypeAny(returnType))) {
|
|
returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
|
|
} else if (!suppressAny) {
|
|
returnTypeNode = factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
}
|
|
let modifiers = options == null ? void 0 : options.modifiers;
|
|
if (kind === 182 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
|
|
const flags = modifiersToFlags(modifiers);
|
|
modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
|
|
}
|
|
const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_a2 = options == null ? void 0 : options.name) != null ? _a2 : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(modifiers, void 0, (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""), void 0, typeParameters, parameters, returnTypeNode, void 0) : kind === 173 /* Constructor */ ? factory.createConstructorDeclaration(modifiers, parameters, void 0) : kind === 174 /* GetAccessor */ ? factory.createGetAccessorDeclaration(modifiers, (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""), parameters, returnTypeNode, void 0) : kind === 175 /* SetAccessor */ ? factory.createSetAccessorDeclaration(modifiers, (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""), parameters, void 0) : kind === 178 /* IndexSignature */ ? factory.createIndexSignature(modifiers, parameters, returnTypeNode) : kind === 320 /* JSDocFunctionType */ ? factory.createJSDocFunctionType(parameters, returnTypeNode) : kind === 181 /* FunctionType */ ? factory.createFunctionTypeNode(typeParameters, parameters, returnTypeNode != null ? returnTypeNode : factory.createTypeReferenceNode(factory.createIdentifier(""))) : kind === 182 /* ConstructorType */ ? factory.createConstructorTypeNode(modifiers, typeParameters, parameters, returnTypeNode != null ? returnTypeNode : factory.createTypeReferenceNode(factory.createIdentifier(""))) : kind === 259 /* FunctionDeclaration */ ? factory.createFunctionDeclaration(modifiers, void 0, (options == null ? void 0 : options.name) ? cast(options.name, isIdentifier) : factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, void 0) : kind === 215 /* FunctionExpression */ ? factory.createFunctionExpression(modifiers, void 0, (options == null ? void 0 : options.name) ? cast(options.name, isIdentifier) : factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, factory.createBlock([])) : kind === 216 /* ArrowFunction */ ? factory.createArrowFunction(modifiers, typeParameters, parameters, returnTypeNode, void 0, factory.createBlock([])) : Debug.assertNever(kind);
|
|
if (typeArguments) {
|
|
node.typeArguments = factory.createNodeArray(typeArguments);
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetThisParameterDeclaration(signature, context) {
|
|
if (signature.thisParameter) {
|
|
return symbolToParameterDeclaration(signature.thisParameter, context);
|
|
}
|
|
if (signature.declaration) {
|
|
const thisTag = getJSDocThisTag(signature.declaration);
|
|
if (thisTag && thisTag.typeExpression) {
|
|
return factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"this",
|
|
void 0,
|
|
typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
|
|
const savedContextFlags = context.flags;
|
|
context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
|
|
const modifiers = factory.createModifiersFromModifierFlags(getVarianceModifiers(type));
|
|
const name = typeParameterToName(type, context);
|
|
const defaultParameter = getDefaultFromTypeParameter(type);
|
|
const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
|
|
context.flags = savedContextFlags;
|
|
return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
|
|
}
|
|
function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
|
|
const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
|
|
return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
|
|
}
|
|
function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
|
|
let parameterDeclaration = getDeclarationOfKind(parameterSymbol, 166 /* Parameter */);
|
|
if (!parameterDeclaration && !isTransientSymbol(parameterSymbol)) {
|
|
parameterDeclaration = getDeclarationOfKind(parameterSymbol, 343 /* JSDocParameterTag */);
|
|
}
|
|
let parameterType = getTypeOfSymbol(parameterSymbol);
|
|
if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
|
|
parameterType = getOptionalType(parameterType);
|
|
}
|
|
const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
|
|
const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
|
|
const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
|
|
const dotDotDotToken = isRest ? factory.createToken(25 /* DotDotDotToken */) : void 0;
|
|
const name = parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 79 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 33554432 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 163 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 33554432 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
|
|
const isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 16384 /* OptionalParameter */;
|
|
const questionToken = isOptional ? factory.createToken(57 /* QuestionToken */) : void 0;
|
|
const parameterNode = factory.createParameterDeclaration(
|
|
modifiers,
|
|
dotDotDotToken,
|
|
name,
|
|
questionToken,
|
|
parameterTypeNode,
|
|
void 0
|
|
);
|
|
context.approximateLength += symbolName(parameterSymbol).length + 3;
|
|
return parameterNode;
|
|
function cloneBindingName(node) {
|
|
return elideInitializerAndSetEmitFlags(node);
|
|
function elideInitializerAndSetEmitFlags(node2) {
|
|
if (context.tracker.trackSymbol && isComputedPropertyName(node2) && isLateBindableName(node2)) {
|
|
trackComputedName(node2.expression, context.enclosingDeclaration, context);
|
|
}
|
|
let visited = visitEachChild(node2, elideInitializerAndSetEmitFlags, nullTransformationContext, void 0, elideInitializerAndSetEmitFlags);
|
|
if (isBindingElement(visited)) {
|
|
visited = factory.updateBindingElement(
|
|
visited,
|
|
visited.dotDotDotToken,
|
|
visited.propertyName,
|
|
visited.name,
|
|
void 0
|
|
);
|
|
}
|
|
if (!nodeIsSynthesized(visited)) {
|
|
visited = factory.cloneNode(visited);
|
|
}
|
|
return setEmitFlags(visited, 1 /* SingleLine */ | 33554432 /* NoAsciiEscaping */);
|
|
}
|
|
}
|
|
}
|
|
function trackComputedName(accessExpression, enclosingDeclaration, context) {
|
|
if (!context.tracker.trackSymbol)
|
|
return;
|
|
const firstIdentifier = getFirstIdentifier(accessExpression);
|
|
const name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 /* Value */ | 1048576 /* ExportValue */, void 0, void 0, true);
|
|
if (name) {
|
|
context.tracker.trackSymbol(name, enclosingDeclaration, 111551 /* Value */);
|
|
}
|
|
}
|
|
function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) {
|
|
context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning);
|
|
return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol);
|
|
}
|
|
function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
|
|
let chain;
|
|
const isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
|
|
if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.flags & 134217728 /* DoNotIncludeSymbolChain */)) {
|
|
chain = Debug.checkDefined(getSymbolChain(symbol, meaning, true));
|
|
Debug.assert(chain && chain.length > 0);
|
|
} else {
|
|
chain = [symbol];
|
|
}
|
|
return chain;
|
|
function getSymbolChain(symbol2, meaning2, endOfChain) {
|
|
let accessibleSymbolChain = getAccessibleSymbolChain(symbol2, context.enclosingDeclaration, meaning2, !!(context.flags & 128 /* UseOnlyExternalAliasing */));
|
|
let parentSpecifiers;
|
|
if (!accessibleSymbolChain || needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning2 : getQualifiedLeftMeaning(meaning2))) {
|
|
const parents = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol2, context.enclosingDeclaration, meaning2);
|
|
if (length(parents)) {
|
|
parentSpecifiers = parents.map((symbol3) => some(symbol3.declarations, hasNonGlobalAugmentationExternalModuleSymbol) ? getSpecifierForModuleSymbol(symbol3, context) : void 0);
|
|
const indices = parents.map((_, i) => i);
|
|
indices.sort(sortByBestName);
|
|
const sortedParents = indices.map((i) => parents[i]);
|
|
for (const parent of sortedParents) {
|
|
const parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning2), false);
|
|
if (parentChain) {
|
|
if (parent.exports && parent.exports.get("export=" /* ExportEquals */) && getSymbolIfSameReference(parent.exports.get("export=" /* ExportEquals */), symbol2)) {
|
|
accessibleSymbolChain = parentChain;
|
|
break;
|
|
}
|
|
accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol2) || symbol2]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (accessibleSymbolChain) {
|
|
return accessibleSymbolChain;
|
|
}
|
|
if (endOfChain || !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))) {
|
|
if (!endOfChain && !yieldModuleSymbol && !!forEach(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
return;
|
|
}
|
|
return [symbol2];
|
|
}
|
|
function sortByBestName(a, b) {
|
|
const specifierA = parentSpecifiers[a];
|
|
const specifierB = parentSpecifiers[b];
|
|
if (specifierA && specifierB) {
|
|
const isBRelative = pathIsRelative(specifierB);
|
|
if (pathIsRelative(specifierA) === isBRelative) {
|
|
return countPathComponents(specifierA) - countPathComponents(specifierB);
|
|
}
|
|
if (isBRelative) {
|
|
return -1;
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
function typeParametersToTypeParameterDeclarations(symbol, context) {
|
|
let typeParameterNodes;
|
|
const targetSymbol = getTargetSymbol(symbol);
|
|
if (targetSymbol.flags & (32 /* Class */ | 64 /* Interface */ | 524288 /* TypeAlias */)) {
|
|
typeParameterNodes = factory.createNodeArray(map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), (tp) => typeParameterToDeclaration(tp, context)));
|
|
}
|
|
return typeParameterNodes;
|
|
}
|
|
function lookupTypeParameterNodes(chain, index, context) {
|
|
var _a2;
|
|
Debug.assert(chain && 0 <= index && index < chain.length);
|
|
const symbol = chain[index];
|
|
const symbolId = getSymbolId(symbol);
|
|
if ((_a2 = context.typeParameterSymbolList) == null ? void 0 : _a2.has(symbolId)) {
|
|
return void 0;
|
|
}
|
|
(context.typeParameterSymbolList || (context.typeParameterSymbolList = /* @__PURE__ */ new Set())).add(symbolId);
|
|
let typeParameterNodes;
|
|
if (context.flags & 512 /* WriteTypeParametersInQualifiedName */ && index < chain.length - 1) {
|
|
const parentSymbol = symbol;
|
|
const nextSymbol = chain[index + 1];
|
|
if (getCheckFlags(nextSymbol) & 1 /* Instantiated */) {
|
|
const params = getTypeParametersOfClassOrInterface(
|
|
parentSymbol.flags & 2097152 /* Alias */ ? resolveAlias(parentSymbol) : parentSymbol
|
|
);
|
|
typeParameterNodes = mapToTypeNodes(map(params, (t) => getMappedType(t, nextSymbol.mapper)), context);
|
|
} else {
|
|
typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context);
|
|
}
|
|
}
|
|
return typeParameterNodes;
|
|
}
|
|
function getTopmostIndexedAccessType(top) {
|
|
if (isIndexedAccessTypeNode(top.objectType)) {
|
|
return getTopmostIndexedAccessType(top.objectType);
|
|
}
|
|
return top;
|
|
}
|
|
function getSpecifierForModuleSymbol(symbol, context, overrideImportMode) {
|
|
var _a2;
|
|
let file = getDeclarationOfKind(symbol, 308 /* SourceFile */);
|
|
if (!file) {
|
|
const equivalentFileSymbol = firstDefined(symbol.declarations, (d) => getFileSymbolIfFileSymbolExportEqualsContainer(d, symbol));
|
|
if (equivalentFileSymbol) {
|
|
file = getDeclarationOfKind(equivalentFileSymbol, 308 /* SourceFile */);
|
|
}
|
|
}
|
|
if (file && file.moduleName !== void 0) {
|
|
return file.moduleName;
|
|
}
|
|
if (!file) {
|
|
if (context.tracker.trackReferencedAmbientModule) {
|
|
const ambientDecls = filter(symbol.declarations, isAmbientModule);
|
|
if (length(ambientDecls)) {
|
|
for (const decl of ambientDecls) {
|
|
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 (ambientModuleSymbolRegex.test(symbol.escapedName)) {
|
|
return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
|
|
}
|
|
return getSourceFileOfNode(getNonAugmentationDeclaration(symbol)).fileName;
|
|
}
|
|
const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration));
|
|
const resolutionMode = overrideImportMode || (contextFile == null ? void 0 : contextFile.impliedNodeFormat);
|
|
const cacheKey = getSpecifierCacheKey(contextFile.path, resolutionMode);
|
|
const links = getSymbolLinks(symbol);
|
|
let specifier = links.specifierCache && links.specifierCache.get(cacheKey);
|
|
if (!specifier) {
|
|
const isBundle2 = !!outFile(compilerOptions);
|
|
const { moduleResolverHost } = context.tracker;
|
|
const specifierCompilerOptions = isBundle2 ? { ...compilerOptions, baseUrl: moduleResolverHost.getCommonSourceDirectory() } : compilerOptions;
|
|
specifier = first(getModuleSpecifiers(
|
|
symbol,
|
|
checker,
|
|
specifierCompilerOptions,
|
|
contextFile,
|
|
moduleResolverHost,
|
|
{
|
|
importModuleSpecifierPreference: isBundle2 ? "non-relative" : "project-relative",
|
|
importModuleSpecifierEnding: isBundle2 ? "minimal" : resolutionMode === 99 /* ESNext */ ? "js" : void 0
|
|
},
|
|
{ overrideImportMode }
|
|
));
|
|
(_a2 = links.specifierCache) != null ? _a2 : links.specifierCache = /* @__PURE__ */ new Map();
|
|
links.specifierCache.set(cacheKey, specifier);
|
|
}
|
|
return specifier;
|
|
function getSpecifierCacheKey(path, mode) {
|
|
return mode === void 0 ? path : `${mode}|${path}`;
|
|
}
|
|
}
|
|
function symbolToEntityNameNode(symbol) {
|
|
const identifier = factory.createIdentifier(unescapeLeadingUnderscores(symbol.escapedName));
|
|
return symbol.parent ? factory.createQualifiedName(symbolToEntityNameNode(symbol.parent), identifier) : identifier;
|
|
}
|
|
function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
|
|
var _a2, _b, _c, _d;
|
|
const chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */));
|
|
const isTypeOf = meaning === 111551 /* Value */;
|
|
if (some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : void 0;
|
|
const typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
|
|
const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration));
|
|
const targetFile = getSourceFileOfModule(chain[0]);
|
|
let specifier;
|
|
let assertion;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
if ((targetFile == null ? void 0 : targetFile.impliedNodeFormat) === 99 /* ESNext */ && targetFile.impliedNodeFormat !== (contextFile == null ? void 0 : contextFile.impliedNodeFormat)) {
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context, 99 /* ESNext */);
|
|
assertion = factory.createImportTypeAssertionContainer(factory.createAssertClause(factory.createNodeArray([
|
|
factory.createAssertEntry(
|
|
factory.createStringLiteral("resolution-mode"),
|
|
factory.createStringLiteral("import")
|
|
)
|
|
])));
|
|
(_b = (_a2 = context.tracker).reportImportTypeNodeResolutionModeOverride) == null ? void 0 : _b.call(_a2);
|
|
}
|
|
}
|
|
if (!specifier) {
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context);
|
|
}
|
|
if (!(context.flags & 67108864 /* AllowNodeModulesRelativePaths */) && getEmitModuleResolutionKind(compilerOptions) !== 1 /* Classic */ && specifier.indexOf("/node_modules/") >= 0) {
|
|
const oldSpecifier = specifier;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
const swappedMode = (contextFile == null ? void 0 : contextFile.impliedNodeFormat) === 99 /* ESNext */ ? 1 /* CommonJS */ : 99 /* ESNext */;
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context, swappedMode);
|
|
if (specifier.indexOf("/node_modules/") >= 0) {
|
|
specifier = oldSpecifier;
|
|
} else {
|
|
assertion = factory.createImportTypeAssertionContainer(factory.createAssertClause(factory.createNodeArray([
|
|
factory.createAssertEntry(
|
|
factory.createStringLiteral("resolution-mode"),
|
|
factory.createStringLiteral(swappedMode === 99 /* ESNext */ ? "import" : "require")
|
|
)
|
|
])));
|
|
(_d = (_c = context.tracker).reportImportTypeNodeResolutionModeOverride) == null ? void 0 : _d.call(_c);
|
|
}
|
|
}
|
|
if (!assertion) {
|
|
context.encounteredError = true;
|
|
if (context.tracker.reportLikelyUnsafeImportRequiredError) {
|
|
context.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier);
|
|
}
|
|
}
|
|
}
|
|
const lit = factory.createLiteralTypeNode(factory.createStringLiteral(specifier));
|
|
if (context.tracker.trackExternalModuleSymbolOfImportTypeNode)
|
|
context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
|
|
context.approximateLength += specifier.length + 10;
|
|
if (!nonRootParts || isEntityName(nonRootParts)) {
|
|
if (nonRootParts) {
|
|
const lastId = isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right;
|
|
lastId.typeArguments = void 0;
|
|
}
|
|
return factory.createImportTypeNode(lit, assertion, nonRootParts, typeParameterNodes, isTypeOf);
|
|
} else {
|
|
const splitNode = getTopmostIndexedAccessType(nonRootParts);
|
|
const qualifier = splitNode.objectType.typeName;
|
|
return factory.createIndexedAccessTypeNode(factory.createImportTypeNode(lit, assertion, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType);
|
|
}
|
|
}
|
|
const entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0);
|
|
if (isIndexedAccessTypeNode(entityName)) {
|
|
return entityName;
|
|
}
|
|
if (isTypeOf) {
|
|
return factory.createTypeQueryNode(entityName);
|
|
} else {
|
|
const lastId = isIdentifier(entityName) ? entityName : entityName.right;
|
|
const lastTypeArgs = lastId.typeArguments;
|
|
lastId.typeArguments = void 0;
|
|
return factory.createTypeReferenceNode(entityName, lastTypeArgs);
|
|
}
|
|
function createAccessFromSymbolChain(chain2, index, stopper) {
|
|
const typeParameterNodes = index === chain2.length - 1 ? overrideTypeArguments : lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
const parent = chain2[index - 1];
|
|
let symbolName2;
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
context.approximateLength += (symbolName2 ? symbolName2.length : 0) + 1;
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
} else {
|
|
if (parent && getExportsOfSymbol(parent)) {
|
|
const exports = getExportsOfSymbol(parent);
|
|
forEachEntry(exports, (ex, name) => {
|
|
if (getSymbolIfSameReference(ex, symbol2) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
|
|
symbolName2 = unescapeLeadingUnderscores(name);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (symbolName2 === void 0) {
|
|
const name = firstDefined(symbol2.declarations, getNameOfDeclaration);
|
|
if (name && isComputedPropertyName(name) && isEntityName(name.expression)) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (isEntityName(LHS)) {
|
|
return factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(LHS)), factory.createTypeQueryNode(name.expression));
|
|
}
|
|
return LHS;
|
|
}
|
|
symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
}
|
|
context.approximateLength += symbolName2.length + 1;
|
|
if (!(context.flags & 16 /* ForbidIndexedAccessSymbolReferences */) && parent && getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol2.escapedName) && getSymbolIfSameReference(getMembersOfSymbol(parent).get(symbol2.escapedName), symbol2)) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (isIndexedAccessTypeNode(LHS)) {
|
|
return factory.createIndexedAccessTypeNode(LHS, factory.createLiteralTypeNode(factory.createStringLiteral(symbolName2)));
|
|
} else {
|
|
return factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(LHS, typeParameterNodes), factory.createLiteralTypeNode(factory.createStringLiteral(symbolName2)));
|
|
}
|
|
}
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
if (index > stopper) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (!isEntityName(LHS)) {
|
|
return Debug.fail("Impossible construct - an export of an indexed access cannot be reachable");
|
|
}
|
|
return factory.createQualifiedName(LHS, identifier);
|
|
}
|
|
return identifier;
|
|
}
|
|
}
|
|
function typeParameterShadowsNameInScope(escapedName, context, type) {
|
|
const result = resolveName(context.enclosingDeclaration, escapedName, 788968 /* Type */, void 0, escapedName, false);
|
|
if (result) {
|
|
if (result.flags & 262144 /* TypeParameter */ && result === type.symbol) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function typeParameterToName(type, context) {
|
|
var _a2, _b;
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
|
|
const cached = context.typeParameterNames.get(getTypeId(type));
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
}
|
|
let result = symbolToName(type.symbol, context, 788968 /* Type */, true);
|
|
if (!(result.kind & 79 /* Identifier */)) {
|
|
return factory.createIdentifier("(Missing type parameter)");
|
|
}
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const rawtext = result.escapedText;
|
|
let i = ((_a2 = context.typeParameterNamesByTextNextNameCount) == null ? void 0 : _a2.get(rawtext)) || 0;
|
|
let text = rawtext;
|
|
while (((_b = context.typeParameterNamesByText) == null ? void 0 : _b.has(text)) || typeParameterShadowsNameInScope(text, context, type)) {
|
|
i++;
|
|
text = `${rawtext}_${i}`;
|
|
}
|
|
if (text !== rawtext) {
|
|
result = factory.createIdentifier(text, result.typeArguments);
|
|
}
|
|
(context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
|
|
(context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
|
|
(context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(rawtext);
|
|
}
|
|
return result;
|
|
}
|
|
function symbolToName(symbol, context, meaning, expectsIdentifier) {
|
|
const chain = lookupSymbolChain(symbol, context, meaning);
|
|
if (expectsIdentifier && chain.length !== 1 && !context.encounteredError && !(context.flags & 65536 /* AllowQualifiedNameInPlaceOfIdentifier */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return createEntityNameFromSymbolChain(chain, chain.length - 1);
|
|
function createEntityNameFromSymbolChain(chain2, index) {
|
|
const typeParameterNodes = lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
}
|
|
const symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
if (index === 0) {
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
}
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
return index > 0 ? factory.createQualifiedName(createEntityNameFromSymbolChain(chain2, index - 1), identifier) : identifier;
|
|
}
|
|
}
|
|
function symbolToExpression(symbol, context, meaning) {
|
|
const chain = lookupSymbolChain(symbol, context, meaning);
|
|
return createExpressionFromSymbolChain(chain, chain.length - 1);
|
|
function createExpressionFromSymbolChain(chain2, index) {
|
|
const typeParameterNodes = lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
}
|
|
let symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
if (index === 0) {
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
}
|
|
let firstChar = symbolName2.charCodeAt(0);
|
|
if (isSingleOrDoubleQuote(firstChar) && some(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
return factory.createStringLiteral(getSpecifierForModuleSymbol(symbol2, context));
|
|
}
|
|
const canUsePropertyAccess = firstChar === 35 /* hash */ ? symbolName2.length > 1 && isIdentifierStart(symbolName2.charCodeAt(1), languageVersion) : isIdentifierStart(firstChar, languageVersion);
|
|
if (index === 0 || canUsePropertyAccess) {
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
return index > 0 ? factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), identifier) : identifier;
|
|
} else {
|
|
if (firstChar === 91 /* openBracket */) {
|
|
symbolName2 = symbolName2.substring(1, symbolName2.length - 1);
|
|
firstChar = symbolName2.charCodeAt(0);
|
|
}
|
|
let expression;
|
|
if (isSingleOrDoubleQuote(firstChar) && !(symbol2.flags & 8 /* EnumMember */)) {
|
|
expression = factory.createStringLiteral(stripQuotes(symbolName2).replace(/\\./g, (s) => s.substring(1)), firstChar === 39 /* singleQuote */);
|
|
} else if ("" + +symbolName2 === symbolName2) {
|
|
expression = factory.createNumericLiteral(+symbolName2);
|
|
}
|
|
if (!expression) {
|
|
expression = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
expression.symbol = symbol2;
|
|
}
|
|
return factory.createElementAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), expression);
|
|
}
|
|
}
|
|
}
|
|
function isStringNamed(d) {
|
|
const name = getNameOfDeclaration(d);
|
|
return !!name && isStringLiteral(name);
|
|
}
|
|
function isSingleQuotedStringNamed(d) {
|
|
const name = getNameOfDeclaration(d);
|
|
return !!(name && isStringLiteral(name) && (name.singleQuote || !nodeIsSynthesized(name) && startsWith(getTextOfNode(name, false), "'")));
|
|
}
|
|
function getPropertyNameNodeForSymbol(symbol, context) {
|
|
const stringNamed = !!length(symbol.declarations) && every(symbol.declarations, isStringNamed);
|
|
const singleQuote = !!length(symbol.declarations) && every(symbol.declarations, isSingleQuotedStringNamed);
|
|
const fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote, stringNamed);
|
|
if (fromNameType) {
|
|
return fromNameType;
|
|
}
|
|
const rawName = unescapeLeadingUnderscores(symbol.escapedName);
|
|
return createPropertyNameNodeForIdentifierOrLiteral(rawName, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed);
|
|
}
|
|
function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote, stringNamed) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType) {
|
|
if (nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const name = "" + nameType.value;
|
|
if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && (stringNamed || !isNumericLiteralName(name))) {
|
|
return factory.createStringLiteral(name, !!singleQuote);
|
|
}
|
|
if (isNumericLiteralName(name) && startsWith(name, "-")) {
|
|
return factory.createComputedPropertyName(factory.createNumericLiteral(+name));
|
|
}
|
|
return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions));
|
|
}
|
|
if (nameType.flags & 8192 /* UniqueESSymbol */) {
|
|
return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* Value */));
|
|
}
|
|
}
|
|
}
|
|
function cloneNodeBuilderContext(context) {
|
|
const initial = { ...context };
|
|
if (initial.typeParameterNames) {
|
|
initial.typeParameterNames = new Map(initial.typeParameterNames);
|
|
}
|
|
if (initial.typeParameterNamesByText) {
|
|
initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
|
|
}
|
|
if (initial.typeParameterSymbolList) {
|
|
initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
|
|
}
|
|
initial.tracker = wrapSymbolTrackerToReportForContext(initial, initial.tracker);
|
|
return initial;
|
|
}
|
|
function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
|
|
return symbol.declarations && find(symbol.declarations, (s) => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
|
|
}
|
|
function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
|
|
return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
|
|
}
|
|
function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
|
|
if (!isErrorType(type) && enclosingDeclaration) {
|
|
const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
|
|
if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
|
|
const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
|
|
if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
|
|
const result2 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const oldFlags = context.flags;
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
|
|
context.flags |= 1048576 /* AllowUniqueESSymbolType */;
|
|
}
|
|
const result = typeToTypeNodeHelper(type, context);
|
|
context.flags = oldFlags;
|
|
return result;
|
|
}
|
|
function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
|
|
const typeFromTypeNode = getTypeFromTypeNode(typeNode);
|
|
if (typeFromTypeNode === type) {
|
|
return true;
|
|
}
|
|
if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
|
|
return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
|
|
}
|
|
return false;
|
|
}
|
|
function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
|
|
if (!isErrorType(type) && context.enclosingDeclaration) {
|
|
const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
|
|
if (!!findAncestor(annotation, (n) => n === context.enclosingDeclaration) && annotation) {
|
|
const annotated = getTypeFromTypeNode(annotation);
|
|
const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
|
|
if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
|
|
const result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return typeToTypeNodeHelper(type, context);
|
|
}
|
|
function trackExistingEntityName(node, context, includePrivateSymbol) {
|
|
var _a2, _b;
|
|
let introducesError = false;
|
|
const leftmost = getFirstIdentifier(node);
|
|
if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
|
|
introducesError = true;
|
|
return { introducesError, node };
|
|
}
|
|
const sym = resolveEntityName(leftmost, 67108863 /* All */, true, true);
|
|
if (sym) {
|
|
if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863 /* All */, false).accessibility !== 0 /* Accessible */) {
|
|
introducesError = true;
|
|
} else {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.trackSymbol) == null ? void 0 : _b.call(_a2, sym, context.enclosingDeclaration, 67108863 /* All */);
|
|
includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
|
|
}
|
|
if (isIdentifier(node)) {
|
|
const type = getDeclaredTypeOfSymbol(sym);
|
|
const name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
|
|
name.symbol = sym;
|
|
return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 33554432 /* NoAsciiEscaping */) };
|
|
}
|
|
}
|
|
return { introducesError, node };
|
|
}
|
|
function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
|
|
if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
let hadError = false;
|
|
const file = getSourceFileOfNode(existing);
|
|
const transformed = visitNode(existing, visitExistingNodeTreeSymbols);
|
|
if (hadError) {
|
|
return void 0;
|
|
}
|
|
return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
|
|
function visitExistingNodeTreeSymbols(node) {
|
|
if (isJSDocAllType(node) || node.kind === 322 /* JSDocNamepathType */) {
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (isJSDocUnknownType(node)) {
|
|
return factory.createKeywordTypeNode(157 /* UnknownKeyword */);
|
|
}
|
|
if (isJSDocNullableType(node)) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols), factory.createLiteralTypeNode(factory.createNull())]);
|
|
}
|
|
if (isJSDocOptionalType(node)) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols), factory.createKeywordTypeNode(155 /* UndefinedKeyword */)]);
|
|
}
|
|
if (isJSDocNonNullableType(node)) {
|
|
return visitNode(node.type, visitExistingNodeTreeSymbols);
|
|
}
|
|
if (isJSDocVariadicType(node)) {
|
|
return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols));
|
|
}
|
|
if (isJSDocTypeLiteral(node)) {
|
|
return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
|
|
const name = isIdentifier(t.name) ? t.name : t.name.right;
|
|
const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
|
|
const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
|
|
return factory.createPropertySignature(
|
|
void 0,
|
|
name,
|
|
t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
}));
|
|
}
|
|
if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") {
|
|
return setOriginalNode(factory.createKeywordTypeNode(131 /* AnyKeyword */), node);
|
|
}
|
|
if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) {
|
|
return factory.createTypeLiteralNode([factory.createIndexSignature(
|
|
void 0,
|
|
[factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"x",
|
|
void 0,
|
|
visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols)
|
|
)],
|
|
visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols)
|
|
)]);
|
|
}
|
|
if (isJSDocFunctionType(node)) {
|
|
if (isJSDocConstructSignature(node)) {
|
|
let newTypeNode;
|
|
return factory.createConstructorTypeNode(
|
|
void 0,
|
|
visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols),
|
|
mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration(
|
|
void 0,
|
|
getEffectiveDotDotDotForParameter(p),
|
|
getNameForJSDocFunctionParameter(p, i),
|
|
p.questionToken,
|
|
visitNode(p.type, visitExistingNodeTreeSymbols),
|
|
void 0
|
|
)),
|
|
visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
} else {
|
|
return factory.createFunctionTypeNode(
|
|
visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols),
|
|
map(node.parameters, (p, i) => factory.createParameterDeclaration(
|
|
void 0,
|
|
getEffectiveDotDotDotForParameter(p),
|
|
getNameForJSDocFunctionParameter(p, i),
|
|
p.questionToken,
|
|
visitNode(p.type, visitExistingNodeTreeSymbols),
|
|
void 0
|
|
)),
|
|
visitNode(node.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
}
|
|
}
|
|
if (isTypeReferenceNode(node) && isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(node, 788968 /* Type */, true))) {
|
|
return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
|
|
}
|
|
if (isLiteralImportTypeNode(node)) {
|
|
const nodeSymbol = getNodeLinks(node).resolvedSymbol;
|
|
if (isInJSDoc(node) && nodeSymbol && (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
|
|
return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
|
|
}
|
|
return factory.updateImportTypeNode(
|
|
node,
|
|
factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)),
|
|
node.assertions,
|
|
node.qualifier,
|
|
visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
|
|
node.isTypeOf
|
|
);
|
|
}
|
|
if (isEntityName(node) || isEntityNameExpression(node)) {
|
|
const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
|
|
hadError = hadError || introducesError;
|
|
if (result !== node) {
|
|
return result;
|
|
}
|
|
}
|
|
if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
|
|
setEmitFlags(node, 1 /* SingleLine */);
|
|
}
|
|
return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
|
|
function getEffectiveDotDotDotForParameter(p) {
|
|
return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(25 /* DotDotDotToken */) : void 0);
|
|
}
|
|
function getNameForJSDocFunctionParameter(p, index) {
|
|
return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
|
|
}
|
|
function rewriteModuleSpecifier(parent, lit) {
|
|
if (bundled) {
|
|
if (context.tracker && context.tracker.moduleResolverHost) {
|
|
const targetFile = getExternalModuleFileFromDeclaration(parent);
|
|
if (targetFile) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(!!host.useCaseSensitiveFileNames);
|
|
const resolverHost = {
|
|
getCanonicalFileName,
|
|
getCurrentDirectory: () => context.tracker.moduleResolverHost.getCurrentDirectory(),
|
|
getCommonSourceDirectory: () => context.tracker.moduleResolverHost.getCommonSourceDirectory()
|
|
};
|
|
const newName = getResolvedExternalModuleName(resolverHost, targetFile);
|
|
return factory.createStringLiteral(newName);
|
|
}
|
|
}
|
|
} else {
|
|
if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) {
|
|
const moduleSym = resolveExternalModuleNameWorker(lit, lit, void 0);
|
|
if (moduleSym) {
|
|
context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym);
|
|
}
|
|
}
|
|
}
|
|
return lit;
|
|
}
|
|
}
|
|
}
|
|
function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
|
|
const serializePropertySymbolForClass = makeSerializePropertySymbol(factory.createPropertyDeclaration, 171 /* MethodDeclaration */, true);
|
|
const serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol((mods, name, question, type) => factory.createPropertySignature(mods, name, question, type), 170 /* MethodSignature */, false);
|
|
const enclosingDeclaration = context.enclosingDeclaration;
|
|
let results = [];
|
|
const visitedSymbols = /* @__PURE__ */ new Set();
|
|
const deferredPrivatesStack = [];
|
|
const oldcontext = context;
|
|
context = {
|
|
...oldcontext,
|
|
usedSymbolNames: new Set(oldcontext.usedSymbolNames),
|
|
remappedSymbolNames: /* @__PURE__ */ new Map(),
|
|
tracker: {
|
|
...oldcontext.tracker,
|
|
trackSymbol: (sym, decl, meaning) => {
|
|
const accessibleResult = isSymbolAccessible(sym, decl, meaning, false);
|
|
if (accessibleResult.accessibility === 0 /* Accessible */) {
|
|
const chain = lookupSymbolChainWorker(sym, context, meaning);
|
|
if (!(sym.flags & 4 /* 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);
|
|
forEachEntry(symbolTable, (symbol, name) => {
|
|
const baseName = unescapeLeadingUnderscores(name);
|
|
void getInternalSymbolName(symbol, baseName);
|
|
});
|
|
let addingDeclare = !bundled;
|
|
const exportEquals = symbolTable.get("export=" /* ExportEquals */);
|
|
if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152 /* Alias */) {
|
|
symbolTable = createSymbolTable();
|
|
symbolTable.set("export=" /* ExportEquals */, exportEquals);
|
|
}
|
|
visitSymbolTable(symbolTable);
|
|
return mergeRedundantStatements(results);
|
|
function isIdentifierAndNotUndefined(node) {
|
|
return !!node && node.kind === 79 /* Identifier */;
|
|
}
|
|
function getNamesOfDeclaration(statement) {
|
|
if (isVariableStatement(statement)) {
|
|
return filter(map(statement.declarationList.declarations, getNameOfDeclaration), isIdentifierAndNotUndefined);
|
|
}
|
|
return filter([getNameOfDeclaration(statement)], isIdentifierAndNotUndefined);
|
|
}
|
|
function flattenExportAssignedNamespace(statements) {
|
|
const exportAssignment = find(statements, isExportAssignment);
|
|
const nsIndex = findIndex(statements, isModuleDeclaration);
|
|
let ns = nsIndex !== -1 ? statements[nsIndex] : void 0;
|
|
if (ns && exportAssignment && exportAssignment.isExportEquals && isIdentifier(exportAssignment.expression) && isIdentifier(ns.name) && idText(ns.name) === idText(exportAssignment.expression) && ns.body && isModuleBlock(ns.body)) {
|
|
const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 1 /* Export */));
|
|
const name = ns.name;
|
|
let body = ns.body;
|
|
if (length(excessExports)) {
|
|
ns = factory.updateModuleDeclaration(
|
|
ns,
|
|
ns.modifiers,
|
|
ns.name,
|
|
body = factory.updateModuleBlock(
|
|
body,
|
|
factory.createNodeArray([...ns.body.statements, factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(map(flatMap(excessExports, (e) => getNamesOfDeclaration(e)), (id) => factory.createExportSpecifier(false, void 0, id))),
|
|
void 0
|
|
)])
|
|
)
|
|
);
|
|
statements = [...statements.slice(0, nsIndex), ns, ...statements.slice(nsIndex + 1)];
|
|
}
|
|
if (!find(statements, (s) => s !== ns && nodeHasName(s, name))) {
|
|
results = [];
|
|
const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 1 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
|
|
forEach(body.statements, (s) => {
|
|
addResult(s, mixinExportFlag ? 1 /* Export */ : 0 /* None */);
|
|
});
|
|
statements = [...filter(statements, (s) => s !== ns && s !== exportAssignment), ...results];
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function mergeExportDeclarations(statements) {
|
|
const exports = filter(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (length(exports) > 1) {
|
|
const nonExports = filter(statements, (d) => !isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause);
|
|
statements = [...nonExports, factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(flatMap(exports, (e) => cast(e.exportClause, isNamedExports).elements)),
|
|
void 0
|
|
)];
|
|
}
|
|
const reexports = filter(statements, (d) => isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (length(reexports) > 1) {
|
|
const groups = group(reexports, (decl) => isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">");
|
|
if (groups.length !== reexports.length) {
|
|
for (const group2 of groups) {
|
|
if (group2.length > 1) {
|
|
statements = [
|
|
...filter(statements, (s) => group2.indexOf(s) === -1),
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(flatMap(group2, (e) => cast(e.exportClause, isNamedExports).elements)),
|
|
group2[0].moduleSpecifier
|
|
)
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function inlineExportModifiers(statements) {
|
|
const index = findIndex(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !d.assertClause && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (index >= 0) {
|
|
const exportDecl = statements[index];
|
|
const replacements = mapDefined(exportDecl.exportClause.elements, (e) => {
|
|
if (!e.propertyName) {
|
|
const indices = indicesOf(statements);
|
|
const associatedIndices = filter(indices, (i) => nodeHasName(statements[i], e.name));
|
|
if (length(associatedIndices) && every(associatedIndices, (i) => canHaveExportModifier(statements[i]))) {
|
|
for (const index2 of associatedIndices) {
|
|
statements[index2] = addExportModifier(statements[index2]);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
return e;
|
|
});
|
|
if (!length(replacements)) {
|
|
orderedRemoveItemAt(statements, index);
|
|
} else {
|
|
statements[index] = factory.updateExportDeclaration(
|
|
exportDecl,
|
|
exportDecl.modifiers,
|
|
exportDecl.isTypeOnly,
|
|
factory.updateNamedExports(
|
|
exportDecl.exportClause,
|
|
replacements
|
|
),
|
|
exportDecl.moduleSpecifier,
|
|
exportDecl.assertClause
|
|
);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function mergeRedundantStatements(statements) {
|
|
statements = flattenExportAssignedNamespace(statements);
|
|
statements = mergeExportDeclarations(statements);
|
|
statements = inlineExportModifiers(statements);
|
|
if (enclosingDeclaration && (isSourceFile(enclosingDeclaration) && isExternalOrCommonJsModule(enclosingDeclaration) || isModuleDeclaration(enclosingDeclaration)) && (!some(statements, isExternalModuleIndicator) || !hasScopeMarker(statements) && some(statements, needsScopeMarker))) {
|
|
statements.push(createEmptyExports(factory));
|
|
}
|
|
return statements;
|
|
}
|
|
function addExportModifier(node) {
|
|
const flags = (getEffectiveModifierFlags(node) | 1 /* Export */) & ~2 /* Ambient */;
|
|
return factory.updateModifiers(node, flags);
|
|
}
|
|
function removeExportModifier(node) {
|
|
const flags = getEffectiveModifierFlags(node) & ~1 /* Export */;
|
|
return factory.updateModifiers(node, flags);
|
|
}
|
|
function visitSymbolTable(symbolTable2, suppressNewPrivateContext, propertyAsAlias) {
|
|
if (!suppressNewPrivateContext) {
|
|
deferredPrivatesStack.push(/* @__PURE__ */ new Map());
|
|
}
|
|
symbolTable2.forEach((symbol) => {
|
|
serializeSymbol(symbol, false, !!propertyAsAlias);
|
|
});
|
|
if (!suppressNewPrivateContext) {
|
|
deferredPrivatesStack[deferredPrivatesStack.length - 1].forEach((symbol) => {
|
|
serializeSymbol(symbol, true, !!propertyAsAlias);
|
|
});
|
|
deferredPrivatesStack.pop();
|
|
}
|
|
}
|
|
function serializeSymbol(symbol, isPrivate, propertyAsAlias) {
|
|
const visitedSym = getMergedSymbol(symbol);
|
|
if (visitedSymbols.has(getSymbolId(visitedSym))) {
|
|
return;
|
|
}
|
|
visitedSymbols.add(getSymbolId(visitedSym));
|
|
const skipMembershipCheck = !isPrivate;
|
|
if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) {
|
|
const oldContext = context;
|
|
context = cloneNodeBuilderContext(context);
|
|
serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
|
|
if (context.reportedDiagnostic) {
|
|
oldcontext.reportedDiagnostic = context.reportedDiagnostic;
|
|
}
|
|
context = oldContext;
|
|
}
|
|
}
|
|
function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
|
|
var _a2, _b, _c, _d;
|
|
const symbolName2 = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const isDefault = symbol.escapedName === "default" /* Default */;
|
|
if (isPrivate && !(context.flags & 131072 /* AllowAnonymousIdentifier */) && isStringANonContextualKeyword(symbolName2) && !isDefault) {
|
|
context.encounteredError = true;
|
|
return;
|
|
}
|
|
let needsPostExportDefault = isDefault && !!(symbol.flags & -113 /* ExportDoesNotSupportDefaultModifier */ || symbol.flags & 16 /* Function */ && length(getPropertiesOfType(getTypeOfSymbol(symbol)))) && !(symbol.flags & 2097152 /* Alias */);
|
|
let needsExportDeclaration = !needsPostExportDefault && !isPrivate && isStringANonContextualKeyword(symbolName2) && !isDefault;
|
|
if (needsPostExportDefault || needsExportDeclaration) {
|
|
isPrivate = true;
|
|
}
|
|
const modifierFlags = (!isPrivate ? 1 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 1024 /* Default */ : 0);
|
|
const isConstMergedWithNS = symbol.flags & 1536 /* Module */ && symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && symbol.escapedName !== "export=" /* ExportEquals */;
|
|
const isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */) || isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
serializeTypeAlias(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && symbol.escapedName !== "export=" /* ExportEquals */ && !(symbol.flags & 4194304 /* Prototype */) && !(symbol.flags & 32 /* Class */) && !(symbol.flags & 8192 /* Method */) && !isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
if (propertyAsAlias) {
|
|
const createdExport = serializeMaybeAliasAssignment(symbol);
|
|
if (createdExport) {
|
|
needsExportDeclaration = false;
|
|
needsPostExportDefault = false;
|
|
}
|
|
} else {
|
|
const type = getTypeOfSymbol(symbol);
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
if (!(symbol.flags & 16 /* Function */) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) {
|
|
serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags);
|
|
} else {
|
|
const flags = !(symbol.flags & 2 /* BlockScopedVariable */) ? ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) && isSourceFile((_b = symbol.parent) == null ? void 0 : _b.valueDeclaration) ? 2 /* Const */ : void 0 : isConstVariable(symbol) ? 2 /* Const */ : 1 /* Let */;
|
|
const name = needsPostExportDefault || !(symbol.flags & 4 /* Property */) ? localName : getUnusedName(localName, symbol);
|
|
let textRange = symbol.declarations && find(symbol.declarations, (d) => isVariableDeclaration(d));
|
|
if (textRange && isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
|
|
textRange = textRange.parent.parent;
|
|
}
|
|
const propertyAccessRequire = (_c = symbol.declarations) == null ? void 0 : _c.find(isPropertyAccessExpression);
|
|
if (propertyAccessRequire && isBinaryExpression(propertyAccessRequire.parent) && isIdentifier(propertyAccessRequire.parent.right) && ((_d = type.symbol) == null ? void 0 : _d.valueDeclaration) && isSourceFile(type.symbol.valueDeclaration)) {
|
|
const alias = localName === propertyAccessRequire.parent.right.escapedText ? void 0 : propertyAccessRequire.parent.right;
|
|
addResult(
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, alias, localName)])
|
|
),
|
|
0 /* None */
|
|
);
|
|
context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* Value */);
|
|
} else {
|
|
const statement = setTextRange(factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(name, void 0, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
|
|
], flags)), textRange);
|
|
addResult(statement, name !== localName ? modifierFlags & ~1 /* Export */ : modifierFlags);
|
|
if (name !== localName && !isPrivate) {
|
|
addResult(
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, name, localName)])
|
|
),
|
|
0 /* None */
|
|
);
|
|
needsExportDeclaration = false;
|
|
needsPostExportDefault = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (symbol.flags & 384 /* Enum */) {
|
|
serializeEnum(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 32 /* Class */) {
|
|
if (symbol.flags & 4 /* Property */ && symbol.valueDeclaration && isBinaryExpression(symbol.valueDeclaration.parent) && isClassExpression(symbol.valueDeclaration.parent.right)) {
|
|
serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
} else {
|
|
serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
}
|
|
if (symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol)) || isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
serializeModule(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 64 /* Interface */ && !(symbol.flags & 32 /* Class */)) {
|
|
serializeInterface(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
if (symbol.flags & 4 /* Property */ && symbol.escapedName === "export=" /* ExportEquals */) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
}
|
|
if (symbol.flags & 8388608 /* ExportStar */) {
|
|
if (symbol.declarations) {
|
|
for (const node of symbol.declarations) {
|
|
const resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (!resolvedModule)
|
|
continue;
|
|
addResult(factory.createExportDeclaration(void 0, false, void 0, factory.createStringLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
if (needsPostExportDefault) {
|
|
addResult(factory.createExportAssignment(void 0, false, factory.createIdentifier(getInternalSymbolName(symbol, symbolName2))), 0 /* None */);
|
|
} else if (needsExportDeclaration) {
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, getInternalSymbolName(symbol, symbolName2), symbolName2)])
|
|
), 0 /* None */);
|
|
}
|
|
}
|
|
function includePrivateSymbol(symbol) {
|
|
if (some(symbol.declarations, isParameterDeclaration))
|
|
return;
|
|
Debug.assertIsDefined(deferredPrivatesStack[deferredPrivatesStack.length - 1]);
|
|
getUnusedName(unescapeLeadingUnderscores(symbol.escapedName), symbol);
|
|
const isExternalImportAlias = !!(symbol.flags & 2097152 /* Alias */) && !some(
|
|
symbol.declarations,
|
|
(d) => !!findAncestor(d, isExportDeclaration) || isNamespaceExport(d) || isImportEqualsDeclaration(d) && !isExternalModuleReference(d.moduleReference)
|
|
);
|
|
deferredPrivatesStack[isExternalImportAlias ? 0 : deferredPrivatesStack.length - 1].set(getSymbolId(symbol), symbol);
|
|
}
|
|
function isExportingScope(enclosingDeclaration2) {
|
|
return isSourceFile(enclosingDeclaration2) && (isExternalOrCommonJsModule(enclosingDeclaration2) || isJsonSourceFile(enclosingDeclaration2)) || isAmbientModule(enclosingDeclaration2) && !isGlobalScopeAugmentation(enclosingDeclaration2);
|
|
}
|
|
function addResult(node, additionalModifierFlags) {
|
|
if (canHaveModifiers(node)) {
|
|
let newModifierFlags = 0 /* None */;
|
|
const enclosingDeclaration2 = context.enclosingDeclaration && (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
|
|
if (additionalModifierFlags & 1 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
|
|
newModifierFlags |= 1 /* Export */;
|
|
}
|
|
if (addingDeclare && !(newModifierFlags & 1 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 16777216 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
|
|
newModifierFlags |= 2 /* Ambient */;
|
|
}
|
|
if (additionalModifierFlags & 1024 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
|
|
newModifierFlags |= 1024 /* Default */;
|
|
}
|
|
if (newModifierFlags) {
|
|
node = factory.updateModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
|
|
}
|
|
}
|
|
results.push(node);
|
|
}
|
|
function serializeTypeAlias(symbol, symbolName2, modifierFlags) {
|
|
var _a2;
|
|
const aliasType = getDeclaredTypeOfTypeAlias(symbol);
|
|
const typeParams = getSymbolLinks(symbol).typeParameters;
|
|
const typeParamDecls = map(typeParams, (p) => typeParameterToDeclaration(p, context));
|
|
const jsdocAliasDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isJSDocTypeAlias);
|
|
const commentText = getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : void 0);
|
|
const oldFlags = context.flags;
|
|
context.flags |= 8388608 /* InTypeAlias */;
|
|
const oldEnclosingDecl = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = jsdocAliasDecl;
|
|
const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) || typeToTypeNodeHelper(aliasType, context);
|
|
addResult(setSyntheticLeadingComments(
|
|
factory.createTypeAliasDeclaration(void 0, getInternalSymbolName(symbol, symbolName2), typeParamDecls, typeNode),
|
|
!commentText ? [] : [{ kind: 3 /* 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, symbolName2, modifierFlags) {
|
|
const interfaceType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
|
|
const baseTypes = getBaseTypes(interfaceType);
|
|
const baseType = length(baseTypes) ? getIntersectionType(baseTypes) : void 0;
|
|
const members = flatMap(getPropertiesOfType(interfaceType), (p) => serializePropertySymbolForInterface(p, baseType));
|
|
const callSignatures = serializeSignatures(0 /* Call */, interfaceType, baseType, 176 /* CallSignature */);
|
|
const constructSignatures = serializeSignatures(1 /* Construct */, interfaceType, baseType, 177 /* ConstructSignature */);
|
|
const indexSignatures = serializeIndexSignatures(interfaceType, baseType);
|
|
const heritageClauses = !length(baseTypes) ? void 0 : [factory.createHeritageClause(94 /* ExtendsKeyword */, mapDefined(baseTypes, (b) => trySerializeAsTypeReference(b, 111551 /* Value */)))];
|
|
addResult(factory.createInterfaceDeclaration(
|
|
void 0,
|
|
getInternalSymbolName(symbol, symbolName2),
|
|
typeParamDecls,
|
|
heritageClauses,
|
|
[...indexSignatures, ...constructSignatures, ...callSignatures, ...members]
|
|
), modifierFlags);
|
|
}
|
|
function getNamespaceMembersForSerialization(symbol) {
|
|
return !symbol.exports ? [] : filter(arrayFrom(symbol.exports.values()), isNamespaceMember);
|
|
}
|
|
function isTypeOnlyNamespace(symbol) {
|
|
return every(getNamespaceMembersForSerialization(symbol), (m) => !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
|
|
}
|
|
function serializeModule(symbol, symbolName2, modifierFlags) {
|
|
const members = getNamespaceMembersForSerialization(symbol);
|
|
const locationMap = arrayToMultiMap(members, (m) => m.parent && m.parent === symbol ? "real" : "merged");
|
|
const realMembers = locationMap.get("real") || emptyArray;
|
|
const mergedMembers = locationMap.get("merged") || emptyArray;
|
|
if (length(realMembers)) {
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 /* Function */ | 67108864 /* Assignment */)));
|
|
}
|
|
if (length(mergedMembers)) {
|
|
const containingFile = getSourceFileOfNode(context.enclosingDeclaration);
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
const nsBody = factory.createModuleBlock([factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(mapDefined(filter(mergedMembers, (n) => n.escapedName !== "export=" /* ExportEquals */), (s) => {
|
|
var _a2, _b;
|
|
const name = unescapeLeadingUnderscores(s.escapedName);
|
|
const localName2 = getInternalSymbolName(s, name);
|
|
const aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s);
|
|
if (containingFile && (aliasDecl ? containingFile !== getSourceFileOfNode(aliasDecl) : !some(s.declarations, (d) => getSourceFileOfNode(d) === containingFile))) {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.reportNonlocalAugmentation) == null ? void 0 : _b.call(_a2, containingFile, symbol, s);
|
|
return void 0;
|
|
}
|
|
const target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
|
|
includePrivateSymbol(target || s);
|
|
const targetName = target ? getInternalSymbolName(target, unescapeLeadingUnderscores(target.escapedName)) : localName2;
|
|
return factory.createExportSpecifier(false, name === targetName ? void 0 : targetName, name);
|
|
}))
|
|
)]);
|
|
addResult(factory.createModuleDeclaration(
|
|
void 0,
|
|
factory.createIdentifier(localName),
|
|
nsBody,
|
|
16 /* Namespace */
|
|
), 0 /* None */);
|
|
}
|
|
}
|
|
function serializeEnum(symbol, symbolName2, modifierFlags) {
|
|
addResult(factory.createEnumDeclaration(
|
|
factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 /* Const */ : 0),
|
|
getInternalSymbolName(symbol, symbolName2),
|
|
map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */)), (p) => {
|
|
const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? getConstantValue2(p.declarations[0]) : void 0;
|
|
return factory.createEnumMember(unescapeLeadingUnderscores(p.escapedName), initializedValue === void 0 ? void 0 : typeof initializedValue === "string" ? factory.createStringLiteral(initializedValue) : factory.createNumericLiteral(initializedValue));
|
|
})
|
|
), modifierFlags);
|
|
}
|
|
function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(sig, 259 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
|
|
addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
|
|
}
|
|
if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
|
|
const props = filter(getPropertiesOfType(type), isNamespaceMember);
|
|
serializeAsNamespaceDeclaration(props, localName, modifierFlags, true);
|
|
}
|
|
}
|
|
function getSignatureTextRangeLocation(signature) {
|
|
if (signature.declaration && signature.declaration.parent) {
|
|
if (isBinaryExpression(signature.declaration.parent) && getAssignmentDeclarationKind(signature.declaration.parent) === 5 /* Property */) {
|
|
return signature.declaration.parent;
|
|
}
|
|
if (isVariableDeclaration(signature.declaration.parent) && signature.declaration.parent.parent) {
|
|
return signature.declaration.parent.parent;
|
|
}
|
|
}
|
|
return signature.declaration;
|
|
}
|
|
function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) {
|
|
if (length(props)) {
|
|
const localVsRemoteMap = arrayToMultiMap(
|
|
props,
|
|
(p) => !length(p.declarations) || some(
|
|
p.declarations,
|
|
(d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)
|
|
) ? "local" : "remote"
|
|
);
|
|
const localProps = localVsRemoteMap.get("local") || emptyArray;
|
|
let fakespace = parseNodeFactory.createModuleDeclaration(void 0, factory.createIdentifier(localName), factory.createModuleBlock([]), 16 /* Namespace */);
|
|
setParent(fakespace, enclosingDeclaration);
|
|
fakespace.locals = createSymbolTable(props);
|
|
fakespace.symbol = props[0].parent;
|
|
const oldResults = results;
|
|
results = [];
|
|
const oldAddingDeclare = addingDeclare;
|
|
addingDeclare = false;
|
|
const subcontext = { ...context, enclosingDeclaration: fakespace };
|
|
const oldContext = context;
|
|
context = subcontext;
|
|
visitSymbolTable(createSymbolTable(localProps), suppressNewPrivateContext, true);
|
|
context = oldContext;
|
|
addingDeclare = oldAddingDeclare;
|
|
const declarations = results;
|
|
results = oldResults;
|
|
const defaultReplaced = map(declarations, (d) => isExportAssignment(d) && !d.isExportEquals && isIdentifier(d.expression) ? factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, d.expression, factory.createIdentifier("default" /* Default */))])
|
|
) : d);
|
|
const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 1 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
|
|
fakespace = factory.updateModuleDeclaration(
|
|
fakespace,
|
|
fakespace.modifiers,
|
|
fakespace.name,
|
|
factory.createModuleBlock(exportModifierStripped)
|
|
);
|
|
addResult(fakespace, modifierFlags);
|
|
}
|
|
}
|
|
function isNamespaceMember(p) {
|
|
return !!(p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) || !(p.flags & 4194304 /* Prototype */ || p.escapedName === "prototype" || p.valueDeclaration && isStatic(p.valueDeclaration) && isClassLike(p.valueDeclaration.parent));
|
|
}
|
|
function sanitizeJSDocImplements(clauses) {
|
|
const result = mapDefined(clauses, (e) => {
|
|
const oldEnclosing = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = e;
|
|
let expr = e.expression;
|
|
if (isEntityNameExpression(expr)) {
|
|
if (isIdentifier(expr) && idText(expr) === "") {
|
|
return cleanup(void 0);
|
|
}
|
|
let introducesError;
|
|
({ introducesError, node: expr } = trackExistingEntityName(expr, context, includePrivateSymbol));
|
|
if (introducesError) {
|
|
return cleanup(void 0);
|
|
}
|
|
}
|
|
return cleanup(factory.createExpressionWithTypeArguments(
|
|
expr,
|
|
map(
|
|
e.typeArguments,
|
|
(a) => serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context)
|
|
)
|
|
));
|
|
function cleanup(result2) {
|
|
context.enclosingDeclaration = oldEnclosing;
|
|
return result2;
|
|
}
|
|
});
|
|
if (result.length === clauses.length) {
|
|
return result;
|
|
}
|
|
return void 0;
|
|
}
|
|
function serializeAsClass(symbol, localName, modifierFlags) {
|
|
var _a2, _b;
|
|
const originalDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
|
|
const oldEnclosing = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = originalDecl || oldEnclosing;
|
|
const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const baseTypes = getBaseTypes(classType);
|
|
const originalImplements = originalDecl && getEffectiveImplementsTypeNodes(originalDecl);
|
|
const implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) || mapDefined(getImplementsTypes(classType), serializeImplementedType);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
const isClass = !!((_b = staticType.symbol) == null ? void 0 : _b.valueDeclaration) && isClassLike(staticType.symbol.valueDeclaration);
|
|
const staticBaseType = isClass ? getBaseConstructorTypeOfClass(staticType) : anyType;
|
|
const heritageClauses = [
|
|
...!length(baseTypes) ? [] : [factory.createHeritageClause(94 /* ExtendsKeyword */, map(baseTypes, (b) => serializeBaseType(b, staticBaseType, localName)))],
|
|
...!length(implementsExpressions) ? [] : [factory.createHeritageClause(117 /* ImplementsKeyword */, implementsExpressions)]
|
|
];
|
|
const symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType));
|
|
const publicSymbolProps = filter(symbolProps, (s) => {
|
|
const valueDecl = s.valueDeclaration;
|
|
return !!valueDecl && !(isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name));
|
|
});
|
|
const hasPrivateIdentifier = some(symbolProps, (s) => {
|
|
const valueDecl = s.valueDeclaration;
|
|
return !!valueDecl && isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name);
|
|
});
|
|
const privateProperties = hasPrivateIdentifier ? [factory.createPropertyDeclaration(
|
|
void 0,
|
|
factory.createPrivateIdentifier("#private"),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)] : emptyArray;
|
|
const publicProperties = flatMap(publicSymbolProps, (p) => serializePropertySymbolForClass(p, false, baseTypes[0]));
|
|
const staticMembers = flatMap(
|
|
filter(getPropertiesOfType(staticType), (p) => !(p.flags & 4194304 /* Prototype */) && p.escapedName !== "prototype" && !isNamespaceMember(p)),
|
|
(p) => serializePropertySymbolForClass(p, true, staticBaseType)
|
|
);
|
|
const isNonConstructableClassLikeInJsFile = !isClass && !!symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && !some(getSignaturesOfType(staticType, 1 /* Construct */));
|
|
const constructors = isNonConstructableClassLikeInJsFile ? [factory.createConstructorDeclaration(factory.createModifiersFromModifierFlags(8 /* Private */), [], void 0)] : serializeSignatures(1 /* Construct */, staticType, staticBaseType, 173 /* Constructor */);
|
|
const indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
|
|
context.enclosingDeclaration = oldEnclosing;
|
|
addResult(setTextRange(factory.createClassDeclaration(
|
|
void 0,
|
|
localName,
|
|
typeParamDecls,
|
|
heritageClauses,
|
|
[...indexSignatures, ...staticMembers, ...constructors, ...publicProperties, ...privateProperties]
|
|
), symbol.declarations && filter(symbol.declarations, (d) => isClassDeclaration(d) || isClassExpression(d))[0]), modifierFlags);
|
|
}
|
|
function getSomeTargetNameFromDeclarations(declarations) {
|
|
return firstDefined(declarations, (d) => {
|
|
if (isImportSpecifier(d) || isExportSpecifier(d)) {
|
|
return idText(d.propertyName || d.name);
|
|
}
|
|
if (isBinaryExpression(d) || isExportAssignment(d)) {
|
|
const expression = isExportAssignment(d) ? d.expression : d.right;
|
|
if (isPropertyAccessExpression(expression)) {
|
|
return idText(expression.name);
|
|
}
|
|
}
|
|
if (isAliasSymbolDeclaration(d)) {
|
|
const name = getNameOfDeclaration(d);
|
|
if (name && isIdentifier(name)) {
|
|
return idText(name);
|
|
}
|
|
}
|
|
return void 0;
|
|
});
|
|
}
|
|
function serializeAsAlias(symbol, localName, modifierFlags) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
const target = getMergedSymbol(getTargetOfAliasDeclaration(node, true));
|
|
if (!target) {
|
|
return;
|
|
}
|
|
let verbatimTargetName = isShorthandAmbientModuleSymbol(target) && getSomeTargetNameFromDeclarations(symbol.declarations) || unescapeLeadingUnderscores(target.escapedName);
|
|
if (verbatimTargetName === "export=" /* ExportEquals */ && (getESModuleInterop(compilerOptions) || compilerOptions.allowSyntheticDefaultImports)) {
|
|
verbatimTargetName = "default" /* Default */;
|
|
}
|
|
const targetName = getInternalSymbolName(target, verbatimTargetName);
|
|
includePrivateSymbol(target);
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
if (((_b = (_a2 = node.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.kind) === 257 /* VariableDeclaration */) {
|
|
const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
|
|
const { propertyName } = node;
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, void 0, factory.createNamedImports([factory.createImportSpecifier(
|
|
false,
|
|
propertyName && isIdentifier(propertyName) ? factory.createIdentifier(idText(propertyName)) : void 0,
|
|
factory.createIdentifier(localName)
|
|
)])),
|
|
factory.createStringLiteral(specifier2),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
}
|
|
Debug.failBadSyntaxKind(((_c = node.parent) == null ? void 0 : _c.parent) || node, "Unhandled binding element grandparent kind in declaration serialization");
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (((_e = (_d = node.parent) == null ? void 0 : _d.parent) == null ? void 0 : _e.kind) === 223 /* BinaryExpression */) {
|
|
serializeExportSpecifier(
|
|
unescapeLeadingUnderscores(symbol.escapedName),
|
|
targetName
|
|
);
|
|
}
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
if (isPropertyAccessExpression(node.initializer)) {
|
|
const initializer = node.initializer;
|
|
const uniqueName = factory.createUniqueName(localName);
|
|
const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
uniqueName,
|
|
factory.createExternalModuleReference(factory.createStringLiteral(specifier2))
|
|
), 0 /* None */);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(localName),
|
|
factory.createQualifiedName(uniqueName, initializer.name)
|
|
), modifierFlags);
|
|
break;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (target.escapedName === "export=" /* ExportEquals */ && some(target.declarations, isJsonSourceFile)) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
break;
|
|
}
|
|
const isLocalImport = !(target.flags & 512 /* ValueModule */) && !isVariableDeclaration(node);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(localName),
|
|
isLocalImport ? symbolToName(target, context, 67108863 /* All */, false) : factory.createExternalModuleReference(factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)))
|
|
), isLocalImport ? modifierFlags : 0 /* None */);
|
|
break;
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
addResult(factory.createNamespaceExportDeclaration(idText(node.name)), 0 /* None */);
|
|
break;
|
|
case 270 /* ImportClause */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, factory.createIdentifier(localName), void 0),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 271 /* NamespaceImport */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, void 0, factory.createNamespaceImport(factory.createIdentifier(localName))),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 277 /* NamespaceExport */:
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamespaceExport(factory.createIdentifier(localName)),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))
|
|
), 0 /* None */);
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory.createNamedImports([
|
|
factory.createImportSpecifier(
|
|
false,
|
|
localName !== verbatimTargetName ? factory.createIdentifier(verbatimTargetName) : void 0,
|
|
factory.createIdentifier(localName)
|
|
)
|
|
])
|
|
),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 278 /* ExportSpecifier */:
|
|
const specifier = node.parent.parent.moduleSpecifier;
|
|
serializeExportSpecifier(
|
|
unescapeLeadingUnderscores(symbol.escapedName),
|
|
specifier ? verbatimTargetName : targetName,
|
|
specifier && isStringLiteralLike(specifier) ? factory.createStringLiteral(specifier.text) : void 0
|
|
);
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
serializeMaybeAliasAssignment(symbol);
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (symbol.escapedName === "default" /* Default */ || symbol.escapedName === "export=" /* ExportEquals */) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
} else {
|
|
serializeExportSpecifier(localName, targetName);
|
|
}
|
|
break;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!");
|
|
}
|
|
}
|
|
function serializeExportSpecifier(localName, targetName, specifier) {
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, localName !== targetName ? targetName : void 0, localName)]),
|
|
specifier
|
|
), 0 /* None */);
|
|
}
|
|
function serializeMaybeAliasAssignment(symbol) {
|
|
if (symbol.flags & 4194304 /* Prototype */) {
|
|
return false;
|
|
}
|
|
const name = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const isExportEquals = name === "export=" /* ExportEquals */;
|
|
const isDefault = name === "default" /* Default */;
|
|
const isExportAssignmentCompatibleSymbolName = isExportEquals || isDefault;
|
|
const aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol);
|
|
const target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
|
|
if (target && length(target.declarations) && some(target.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(enclosingDeclaration))) {
|
|
const expr = aliasDecl && (isExportAssignment(aliasDecl) || isBinaryExpression(aliasDecl) ? getExportAssignmentExpression(aliasDecl) : getPropertyAssignmentAliasLikeExpression(aliasDecl));
|
|
const first2 = expr && isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : void 0;
|
|
const referenced = first2 && resolveEntityName(first2, 67108863 /* All */, true, true, enclosingDeclaration);
|
|
if (referenced || target) {
|
|
includePrivateSymbol(referenced || target);
|
|
}
|
|
const oldTrack = context.tracker.trackSymbol;
|
|
context.tracker.trackSymbol = () => false;
|
|
if (isExportAssignmentCompatibleSymbolName) {
|
|
results.push(factory.createExportAssignment(
|
|
void 0,
|
|
isExportEquals,
|
|
symbolToExpression(target, context, 67108863 /* All */)
|
|
));
|
|
} else {
|
|
if (first2 === expr && first2) {
|
|
serializeExportSpecifier(name, idText(first2));
|
|
} else if (expr && isClassExpression(expr)) {
|
|
serializeExportSpecifier(name, getInternalSymbolName(target, symbolName(target)));
|
|
} else {
|
|
const varName = getUnusedName(name, symbol);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(varName),
|
|
symbolToName(target, context, 67108863 /* All */, false)
|
|
), 0 /* None */);
|
|
serializeExportSpecifier(name, varName);
|
|
}
|
|
}
|
|
context.tracker.trackSymbol = oldTrack;
|
|
return true;
|
|
} else {
|
|
const varName = getUnusedName(name, symbol);
|
|
const typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
|
|
if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
|
|
serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 1 /* Export */);
|
|
} else {
|
|
const statement = factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(varName, void 0, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
|
|
], 2 /* Const */));
|
|
addResult(
|
|
statement,
|
|
target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 2 /* Ambient */ : name === varName ? 1 /* Export */ : 0 /* None */
|
|
);
|
|
}
|
|
if (isExportAssignmentCompatibleSymbolName) {
|
|
results.push(factory.createExportAssignment(
|
|
void 0,
|
|
isExportEquals,
|
|
factory.createIdentifier(varName)
|
|
));
|
|
return true;
|
|
} else if (name !== varName) {
|
|
serializeExportSpecifier(name, varName);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
|
|
const ctxSrc = getSourceFileOfNode(context.enclosingDeclaration);
|
|
return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && !!(length(filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || length(getSignaturesOfType(typeToSerialize, 0 /* Call */))) && !length(getSignaturesOfType(typeToSerialize, 1 /* Construct */)) && !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) && !(typeToSerialize.symbol && some(typeToSerialize.symbol.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && !some(getPropertiesOfType(typeToSerialize), (p) => isLateBoundName(p.escapedName)) && !some(getPropertiesOfType(typeToSerialize), (p) => some(p.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && every(getPropertiesOfType(typeToSerialize), (p) => isIdentifierText(symbolName(p), languageVersion));
|
|
}
|
|
function makeSerializePropertySymbol(createProperty, methodKind, useAccessors) {
|
|
return function serializePropertySymbol(p, isStatic2, baseType) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
|
|
const isPrivate = !!(modifierFlags & 8 /* Private */);
|
|
if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
|
|
return [];
|
|
}
|
|
if (p.flags & 4194304 /* Prototype */ || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
|
|
return [];
|
|
}
|
|
const flag = modifierFlags & ~512 /* Async */ | (isStatic2 ? 32 /* Static */ : 0);
|
|
const name = getPropertyNameNodeForSymbol(p, context);
|
|
const firstPropertyLikeDecl = (_a2 = p.declarations) == null ? void 0 : _a2.find(or(isPropertyDeclaration, isAccessor, isVariableDeclaration, isPropertySignature, isBinaryExpression, isPropertyAccessExpression));
|
|
if (p.flags & 98304 /* Accessor */ && useAccessors) {
|
|
const result = [];
|
|
if (p.flags & 65536 /* SetAccessor */) {
|
|
result.push(setTextRange(factory.createSetAccessorDeclaration(
|
|
factory.createModifiersFromModifierFlags(flag),
|
|
name,
|
|
[factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"arg",
|
|
void 0,
|
|
isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
|
|
)],
|
|
void 0
|
|
), ((_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor)) || firstPropertyLikeDecl));
|
|
}
|
|
if (p.flags & 32768 /* GetAccessor */) {
|
|
const isPrivate2 = modifierFlags & 8 /* Private */;
|
|
result.push(setTextRange(factory.createGetAccessorDeclaration(
|
|
factory.createModifiersFromModifierFlags(flag),
|
|
name,
|
|
[],
|
|
isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
|
|
void 0
|
|
), ((_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor)) || firstPropertyLikeDecl));
|
|
}
|
|
return result;
|
|
} else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
|
|
return setTextRange(createProperty(
|
|
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
|
|
name,
|
|
p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
|
|
void 0
|
|
), ((_d = p.declarations) == null ? void 0 : _d.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl);
|
|
}
|
|
if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
|
|
const type = getTypeOfSymbol(p);
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
if (flag & 8 /* Private */) {
|
|
return setTextRange(createProperty(
|
|
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
|
|
name,
|
|
p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
void 0,
|
|
void 0
|
|
), ((_e = p.declarations) == null ? void 0 : _e.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0]);
|
|
}
|
|
const results2 = [];
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(
|
|
sig,
|
|
methodKind,
|
|
context,
|
|
{
|
|
name,
|
|
questionToken: p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
modifiers: flag ? factory.createModifiersFromModifierFlags(flag) : void 0
|
|
}
|
|
);
|
|
const location = sig.declaration && isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration;
|
|
results2.push(setTextRange(decl, location));
|
|
}
|
|
return results2;
|
|
}
|
|
return Debug.fail(`Unhandled class member kind! ${p.__debugFlags || p.flags}`);
|
|
};
|
|
}
|
|
function serializePropertySymbolForInterface(p, baseType) {
|
|
return serializePropertySymbolForInterfaceWorker(p, false, baseType);
|
|
}
|
|
function serializeSignatures(kind, input, baseType, outputKind) {
|
|
const signatures = getSignaturesOfType(input, kind);
|
|
if (kind === 1 /* Construct */) {
|
|
if (!baseType && every(signatures, (s) => length(s.parameters) === 0)) {
|
|
return [];
|
|
}
|
|
if (baseType) {
|
|
const baseSigs = getSignaturesOfType(baseType, 1 /* Construct */);
|
|
if (!length(baseSigs) && every(signatures, (s) => length(s.parameters) === 0)) {
|
|
return [];
|
|
}
|
|
if (baseSigs.length === signatures.length) {
|
|
let failed = false;
|
|
for (let i = 0; i < baseSigs.length; i++) {
|
|
if (!compareSignaturesIdentical(signatures[i], baseSigs[i], false, false, true, compareTypesIdentical)) {
|
|
failed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!failed) {
|
|
return [];
|
|
}
|
|
}
|
|
}
|
|
let privateProtected = 0;
|
|
for (const s of signatures) {
|
|
if (s.declaration) {
|
|
privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 8 /* Private */ | 16 /* Protected */);
|
|
}
|
|
}
|
|
if (privateProtected) {
|
|
return [setTextRange(factory.createConstructorDeclaration(
|
|
factory.createModifiersFromModifierFlags(privateProtected),
|
|
[],
|
|
void 0
|
|
), signatures[0].declaration)];
|
|
}
|
|
}
|
|
const results2 = [];
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
|
|
results2.push(setTextRange(decl, sig.declaration));
|
|
}
|
|
return results2;
|
|
}
|
|
function serializeIndexSignatures(input, baseType) {
|
|
const results2 = [];
|
|
for (const info of getIndexInfosOfType(input)) {
|
|
if (baseType) {
|
|
const baseInfo = getIndexInfoOfType(baseType, info.keyType);
|
|
if (baseInfo) {
|
|
if (isTypeIdenticalTo(info.type, baseInfo.type)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
results2.push(indexInfoToIndexSignatureDeclarationHelper(info, context, void 0));
|
|
}
|
|
return results2;
|
|
}
|
|
function serializeBaseType(t, staticType, rootName) {
|
|
const ref = trySerializeAsTypeReference(t, 111551 /* Value */);
|
|
if (ref) {
|
|
return ref;
|
|
}
|
|
const tempName = getUnusedName(`${rootName}_base`);
|
|
const statement = factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(tempName, void 0, typeToTypeNodeHelper(staticType, context))
|
|
], 2 /* Const */));
|
|
addResult(statement, 0 /* None */);
|
|
return factory.createExpressionWithTypeArguments(factory.createIdentifier(tempName), void 0);
|
|
}
|
|
function trySerializeAsTypeReference(t, flags) {
|
|
let typeArgs;
|
|
let reference;
|
|
if (t.target && isSymbolAccessibleByFlags(t.target.symbol, enclosingDeclaration, flags)) {
|
|
typeArgs = map(getTypeArguments(t), (t2) => typeToTypeNodeHelper(t2, context));
|
|
reference = symbolToExpression(t.target.symbol, context, 788968 /* Type */);
|
|
} else if (t.symbol && isSymbolAccessibleByFlags(t.symbol, enclosingDeclaration, flags)) {
|
|
reference = symbolToExpression(t.symbol, context, 788968 /* Type */);
|
|
}
|
|
if (reference) {
|
|
return factory.createExpressionWithTypeArguments(reference, typeArgs);
|
|
}
|
|
}
|
|
function serializeImplementedType(t) {
|
|
const ref = trySerializeAsTypeReference(t, 788968 /* Type */);
|
|
if (ref) {
|
|
return ref;
|
|
}
|
|
if (t.symbol) {
|
|
return factory.createExpressionWithTypeArguments(symbolToExpression(t.symbol, context, 788968 /* Type */), void 0);
|
|
}
|
|
}
|
|
function getUnusedName(input, symbol) {
|
|
var _a2, _b;
|
|
const id = symbol ? getSymbolId(symbol) : void 0;
|
|
if (id) {
|
|
if (context.remappedSymbolNames.has(id)) {
|
|
return context.remappedSymbolNames.get(id);
|
|
}
|
|
}
|
|
if (symbol) {
|
|
input = getNameCandidateWorker(symbol, input);
|
|
}
|
|
let i = 0;
|
|
const original = input;
|
|
while ((_a2 = context.usedSymbolNames) == null ? void 0 : _a2.has(input)) {
|
|
i++;
|
|
input = `${original}_${i}`;
|
|
}
|
|
(_b = context.usedSymbolNames) == null ? void 0 : _b.add(input);
|
|
if (id) {
|
|
context.remappedSymbolNames.set(id, input);
|
|
}
|
|
return input;
|
|
}
|
|
function getNameCandidateWorker(symbol, localName) {
|
|
if (localName === "default" /* Default */ || localName === "__class" /* Class */ || localName === "__function" /* Function */) {
|
|
const flags = context.flags;
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
const nameCandidate = getNameOfSymbolAsWritten(symbol, context);
|
|
context.flags = flags;
|
|
localName = nameCandidate.length > 0 && isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? stripQuotes(nameCandidate) : nameCandidate;
|
|
}
|
|
if (localName === "default" /* Default */) {
|
|
localName = "_default";
|
|
} else if (localName === "export=" /* ExportEquals */) {
|
|
localName = "_exports";
|
|
}
|
|
localName = isIdentifierText(localName, languageVersion) && !isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_");
|
|
return localName;
|
|
}
|
|
function getInternalSymbolName(symbol, localName) {
|
|
const id = getSymbolId(symbol);
|
|
if (context.remappedSymbolNames.has(id)) {
|
|
return context.remappedSymbolNames.get(id);
|
|
}
|
|
localName = getNameCandidateWorker(symbol, localName);
|
|
context.remappedSymbolNames.set(id, localName);
|
|
return localName;
|
|
}
|
|
}
|
|
}
|
|
function typePredicateToString(typePredicate, enclosingDeclaration, flags = 16384 /* UseAliasDefinedOutsideCurrentScope */, writer) {
|
|
return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
|
|
function typePredicateToStringWorker(writer2) {
|
|
const predicate = factory.createTypePredicateNode(
|
|
typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(129 /* AssertsKeyword */) : void 0,
|
|
typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createIdentifier(typePredicate.parameterName) : factory.createThisTypeNode(),
|
|
typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */)
|
|
);
|
|
const printer = createPrinter({ removeComments: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, predicate, sourceFile, writer2);
|
|
return writer2;
|
|
}
|
|
}
|
|
function formatUnionTypes(types) {
|
|
const result = [];
|
|
let flags = 0;
|
|
for (let i = 0; i < types.length; i++) {
|
|
const t = types[i];
|
|
flags |= t.flags;
|
|
if (!(t.flags & 98304 /* Nullable */)) {
|
|
if (t.flags & (512 /* BooleanLiteral */ | 1024 /* EnumLiteral */)) {
|
|
const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLiteralType(t);
|
|
if (baseType.flags & 1048576 /* Union */) {
|
|
const 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 /* Null */)
|
|
result.push(nullType);
|
|
if (flags & 32768 /* Undefined */)
|
|
result.push(undefinedType);
|
|
return result || types;
|
|
}
|
|
function visibilityToString(flags) {
|
|
if (flags === 8 /* Private */) {
|
|
return "private";
|
|
}
|
|
if (flags === 16 /* Protected */) {
|
|
return "protected";
|
|
}
|
|
return "public";
|
|
}
|
|
function getTypeAliasForTypeLiteral(type) {
|
|
if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && type.symbol.declarations) {
|
|
const node = walkUpParenthesizedTypes(type.symbol.declarations[0].parent);
|
|
if (node.kind === 262 /* TypeAliasDeclaration */) {
|
|
return getSymbolOfNode(node);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isTopLevelInExternalModuleAugmentation(node) {
|
|
return node && node.parent && node.parent.kind === 265 /* ModuleBlock */ && isExternalModuleAugmentation(node.parent.parent);
|
|
}
|
|
function isDefaultBindingContext(location) {
|
|
return location.kind === 308 /* SourceFile */ || isAmbientModule(location);
|
|
}
|
|
function getNameOfSymbolFromNameType(symbol, context) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType) {
|
|
if (nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const name = "" + nameType.value;
|
|
if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
|
|
return `"${escapeString(name, 34 /* doubleQuote */)}"`;
|
|
}
|
|
if (isNumericLiteralName(name) && startsWith(name, "-")) {
|
|
return `[${name}]`;
|
|
}
|
|
return name;
|
|
}
|
|
if (nameType.flags & 8192 /* UniqueESSymbol */) {
|
|
return `[${getNameOfSymbolAsWritten(nameType.symbol, context)}]`;
|
|
}
|
|
}
|
|
}
|
|
function getNameOfSymbolAsWritten(symbol, context) {
|
|
if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && (!(context.flags & 16777216 /* InInitialEntityName */) || !symbol.declarations || context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
|
|
return "default";
|
|
}
|
|
if (symbol.declarations && symbol.declarations.length) {
|
|
let declaration = firstDefined(symbol.declarations, (d) => getNameOfDeclaration(d) ? d : void 0);
|
|
const name2 = declaration && getNameOfDeclaration(declaration);
|
|
if (declaration && name2) {
|
|
if (isCallExpression(declaration) && isBindableObjectDefinePropertyCall(declaration)) {
|
|
return symbolName(symbol);
|
|
}
|
|
if (isComputedPropertyName(name2) && !(getCheckFlags(symbol) & 4096 /* Late */)) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType && nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const result = getNameOfSymbolFromNameType(symbol, context);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return declarationNameToString(name2);
|
|
}
|
|
if (!declaration) {
|
|
declaration = symbol.declarations[0];
|
|
}
|
|
if (declaration.parent && declaration.parent.kind === 257 /* VariableDeclaration */) {
|
|
return declarationNameToString(declaration.parent.name);
|
|
}
|
|
switch (declaration.kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (context && !context.encounteredError && !(context.flags & 131072 /* AllowAnonymousIdentifier */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return declaration.kind === 228 /* ClassExpression */ ? "(Anonymous class)" : "(Anonymous function)";
|
|
}
|
|
}
|
|
const name = getNameOfSymbolFromNameType(symbol, context);
|
|
return name !== void 0 ? name : symbolName(symbol);
|
|
}
|
|
function isDeclarationVisible(node) {
|
|
if (node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.isVisible === void 0) {
|
|
links.isVisible = !!determineIfDeclarationIsVisible();
|
|
}
|
|
return links.isVisible;
|
|
}
|
|
return false;
|
|
function determineIfDeclarationIsVisible() {
|
|
switch (node.kind) {
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return !!(node.parent && node.parent.parent && node.parent.parent.parent && isSourceFile(node.parent.parent.parent));
|
|
case 205 /* BindingElement */:
|
|
return isDeclarationVisible(node.parent.parent);
|
|
case 257 /* VariableDeclaration */:
|
|
if (isBindingPattern(node.name) && !node.name.elements.length) {
|
|
return false;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (isExternalModuleAugmentation(node)) {
|
|
return true;
|
|
}
|
|
const parent = getDeclarationContainer(node);
|
|
if (!(getCombinedModifierFlags(node) & 1 /* Export */) && !(node.kind !== 268 /* ImportEqualsDeclaration */ && parent.kind !== 308 /* SourceFile */ && parent.flags & 16777216 /* Ambient */)) {
|
|
return isGlobalSourceFile(parent);
|
|
}
|
|
return isDeclarationVisible(parent);
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (hasEffectiveModifier(node, 8 /* Private */ | 16 /* Protected */)) {
|
|
return false;
|
|
}
|
|
case 173 /* Constructor */:
|
|
case 177 /* ConstructSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 166 /* Parameter */:
|
|
case 265 /* ModuleBlock */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 180 /* TypeReference */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
return isDeclarationVisible(node.parent);
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
return false;
|
|
case 165 /* TypeParameter */:
|
|
case 308 /* SourceFile */:
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return true;
|
|
case 274 /* ExportAssignment */:
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function collectLinkedAliases(node, setVisibility) {
|
|
let exportSymbol;
|
|
if (node.parent && node.parent.kind === 274 /* ExportAssignment */) {
|
|
exportSymbol = resolveName(node, node.escapedText, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */, void 0, node, false);
|
|
} else if (node.parent.kind === 278 /* ExportSpecifier */) {
|
|
exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
}
|
|
let result;
|
|
let visited;
|
|
if (exportSymbol) {
|
|
visited = /* @__PURE__ */ new Set();
|
|
visited.add(getSymbolId(exportSymbol));
|
|
buildVisibleNodeList(exportSymbol.declarations);
|
|
}
|
|
return result;
|
|
function buildVisibleNodeList(declarations) {
|
|
forEach(declarations, (declaration) => {
|
|
const resultNode = getAnyImportSyntax(declaration) || declaration;
|
|
if (setVisibility) {
|
|
getNodeLinks(declaration).isVisible = true;
|
|
} else {
|
|
result = result || [];
|
|
pushIfUnique(result, resultNode);
|
|
}
|
|
if (isInternalModuleImportEqualsDeclaration(declaration)) {
|
|
const internalModuleReference = declaration.moduleReference;
|
|
const firstIdentifier = getFirstIdentifier(internalModuleReference);
|
|
const importSymbol = resolveName(
|
|
declaration,
|
|
firstIdentifier.escapedText,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */,
|
|
void 0,
|
|
void 0,
|
|
false
|
|
);
|
|
if (importSymbol && visited) {
|
|
if (tryAddToSet(visited, getSymbolId(importSymbol))) {
|
|
buildVisibleNodeList(importSymbol.declarations);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function pushTypeResolution(target, propertyName) {
|
|
const resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
|
|
if (resolutionCycleStartIndex >= 0) {
|
|
const { length: length2 } = resolutionTargets;
|
|
for (let i = resolutionCycleStartIndex; i < length2; i++) {
|
|
resolutionResults[i] = false;
|
|
}
|
|
return false;
|
|
}
|
|
resolutionTargets.push(target);
|
|
resolutionResults.push(true);
|
|
resolutionPropertyNames.push(propertyName);
|
|
return true;
|
|
}
|
|
function findResolutionCycleStartIndex(target, propertyName) {
|
|
for (let i = resolutionTargets.length - 1; i >= 0; i--) {
|
|
if (hasType2(resolutionTargets[i], resolutionPropertyNames[i])) {
|
|
return -1;
|
|
}
|
|
if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function hasType2(target, propertyName) {
|
|
switch (propertyName) {
|
|
case 0 /* Type */:
|
|
return !!getSymbolLinks(target).type;
|
|
case 5 /* EnumTagType */:
|
|
return !!getNodeLinks(target).resolvedEnumType;
|
|
case 2 /* DeclaredType */:
|
|
return !!getSymbolLinks(target).declaredType;
|
|
case 1 /* ResolvedBaseConstructorType */:
|
|
return !!target.resolvedBaseConstructorType;
|
|
case 3 /* ResolvedReturnType */:
|
|
return !!target.resolvedReturnType;
|
|
case 4 /* ImmediateBaseConstraint */:
|
|
return !!target.immediateBaseConstraint;
|
|
case 6 /* ResolvedTypeArguments */:
|
|
return !!target.resolvedTypeArguments;
|
|
case 7 /* ResolvedBaseTypes */:
|
|
return !!target.baseTypesResolved;
|
|
case 8 /* WriteType */:
|
|
return !!getSymbolLinks(target).writeType;
|
|
}
|
|
return Debug.assertNever(propertyName);
|
|
}
|
|
function popTypeResolution() {
|
|
resolutionTargets.pop();
|
|
resolutionPropertyNames.pop();
|
|
return resolutionResults.pop();
|
|
}
|
|
function getDeclarationContainer(node) {
|
|
return findAncestor(getRootDeclaration(node), (node2) => {
|
|
switch (node2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 258 /* VariableDeclarationList */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 272 /* NamedImports */:
|
|
case 271 /* NamespaceImport */:
|
|
case 270 /* ImportClause */:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}).parent;
|
|
}
|
|
function getTypeOfPrototypeProperty(prototype) {
|
|
const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
|
|
return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
|
|
}
|
|
function getTypeOfPropertyOfType(type, name) {
|
|
const prop = getPropertyOfType(type, name);
|
|
return prop ? getTypeOfSymbol(prop) : void 0;
|
|
}
|
|
function getTypeOfPropertyOrIndexSignature(type, name) {
|
|
var _a2;
|
|
return getTypeOfPropertyOfType(type, name) || ((_a2 = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a2.type) || unknownType;
|
|
}
|
|
function isTypeAny(type) {
|
|
return type && (type.flags & 1 /* Any */) !== 0;
|
|
}
|
|
function isErrorType(type) {
|
|
return type === errorType || !!(type.flags & 1 /* Any */ && type.aliasSymbol);
|
|
}
|
|
function getTypeForBindingElementParent(node, checkMode) {
|
|
if (checkMode !== 0 /* Normal */) {
|
|
return getTypeForVariableLikeDeclaration(node, false, checkMode);
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false, checkMode);
|
|
}
|
|
function getRestType(source, properties, symbol) {
|
|
source = filterType(source, (t) => !(t.flags & 98304 /* Nullable */));
|
|
if (source.flags & 131072 /* Never */) {
|
|
return emptyObjectType;
|
|
}
|
|
if (source.flags & 1048576 /* Union */) {
|
|
return mapType(source, (t) => getRestType(t, properties, symbol));
|
|
}
|
|
let omitKeyType = getUnionType(map(properties, getLiteralTypeFromPropertyName));
|
|
const spreadableProperties = [];
|
|
const unspreadableToRestKeys = [];
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
|
|
if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) && isSpreadableProperty(prop)) {
|
|
spreadableProperties.push(prop);
|
|
} else {
|
|
unspreadableToRestKeys.push(literalTypeFromProperty);
|
|
}
|
|
}
|
|
if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) {
|
|
if (unspreadableToRestKeys.length) {
|
|
omitKeyType = getUnionType([omitKeyType, ...unspreadableToRestKeys]);
|
|
}
|
|
if (omitKeyType.flags & 131072 /* Never */) {
|
|
return source;
|
|
}
|
|
const omitTypeAlias = getGlobalOmitSymbol();
|
|
if (!omitTypeAlias) {
|
|
return errorType;
|
|
}
|
|
return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
|
|
}
|
|
const members = createSymbolTable();
|
|
for (const prop of spreadableProperties) {
|
|
members.set(prop.escapedName, getSpreadSymbol(prop, false));
|
|
}
|
|
const result = createAnonymousType(symbol, members, emptyArray, emptyArray, getIndexInfosOfType(source));
|
|
result.objectFlags |= 4194304 /* ObjectRestType */;
|
|
return result;
|
|
}
|
|
function isGenericTypeWithUndefinedConstraint(type) {
|
|
return !!(type.flags & 465829888 /* Instantiable */) && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 32768 /* Undefined */);
|
|
}
|
|
function getNonUndefinedType(type) {
|
|
const typeOrConstraint = someType(type, isGenericTypeWithUndefinedConstraint) ? mapType(type, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t) : type;
|
|
return getTypeWithFacts(typeOrConstraint, 524288 /* NEUndefined */);
|
|
}
|
|
function getFlowTypeOfDestructuring(node, declaredType) {
|
|
const reference = getSyntheticElementAccess(node);
|
|
return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType;
|
|
}
|
|
function getSyntheticElementAccess(node) {
|
|
const parentAccess = getParentElementAccess(node);
|
|
if (parentAccess && parentAccess.flowNode) {
|
|
const propName = getDestructuringPropertyName(node);
|
|
if (propName) {
|
|
const literal = setTextRange(parseNodeFactory.createStringLiteral(propName), node);
|
|
const lhsExpr = isLeftHandSideExpression(parentAccess) ? parentAccess : parseNodeFactory.createParenthesizedExpression(parentAccess);
|
|
const result = setTextRange(parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
|
|
setParent(literal, result);
|
|
setParent(result, node);
|
|
if (lhsExpr !== parentAccess) {
|
|
setParent(lhsExpr, result);
|
|
}
|
|
result.flowNode = parentAccess.flowNode;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function getParentElementAccess(node) {
|
|
const ancestor = node.parent.parent;
|
|
switch (ancestor.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 299 /* PropertyAssignment */:
|
|
return getSyntheticElementAccess(ancestor);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return getSyntheticElementAccess(node.parent);
|
|
case 257 /* VariableDeclaration */:
|
|
return ancestor.initializer;
|
|
case 223 /* BinaryExpression */:
|
|
return ancestor.right;
|
|
}
|
|
}
|
|
function getDestructuringPropertyName(node) {
|
|
const parent = node.parent;
|
|
if (node.kind === 205 /* BindingElement */ && parent.kind === 203 /* ObjectBindingPattern */) {
|
|
return getLiteralPropertyNameText(node.propertyName || node.name);
|
|
}
|
|
if (node.kind === 299 /* PropertyAssignment */ || node.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return getLiteralPropertyNameText(node.name);
|
|
}
|
|
return "" + parent.elements.indexOf(node);
|
|
}
|
|
function getLiteralPropertyNameText(name) {
|
|
const type = getLiteralTypeFromPropertyName(name);
|
|
return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
|
|
}
|
|
function getTypeForBindingElement(declaration) {
|
|
const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
|
|
const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
|
|
return parentType && getBindingElementTypeFromParentType(declaration, parentType);
|
|
}
|
|
function getBindingElementTypeFromParentType(declaration, parentType) {
|
|
if (isTypeAny(parentType)) {
|
|
return parentType;
|
|
}
|
|
const pattern = declaration.parent;
|
|
if (strictNullChecks && declaration.flags & 16777216 /* Ambient */ && isParameterDeclaration(declaration)) {
|
|
parentType = getNonNullableType(parentType);
|
|
} else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* EQUndefined */)) {
|
|
parentType = getTypeWithFacts(parentType, 524288 /* NEUndefined */);
|
|
}
|
|
let type;
|
|
if (pattern.kind === 203 /* ObjectBindingPattern */) {
|
|
if (declaration.dotDotDotToken) {
|
|
parentType = getReducedType(parentType);
|
|
if (parentType.flags & 2 /* Unknown */ || !isValidSpreadType(parentType)) {
|
|
error(declaration, Diagnostics.Rest_types_may_only_be_created_from_object_types);
|
|
return errorType;
|
|
}
|
|
const literalMembers = [];
|
|
for (const element of pattern.elements) {
|
|
if (!element.dotDotDotToken) {
|
|
literalMembers.push(element.propertyName || element.name);
|
|
}
|
|
}
|
|
type = getRestType(parentType, literalMembers, declaration.symbol);
|
|
} else {
|
|
const name = declaration.propertyName || declaration.name;
|
|
const indexType = getLiteralTypeFromPropertyName(name);
|
|
const declaredType = getIndexedAccessType(parentType, indexType, 32 /* ExpressionPosition */, name);
|
|
type = getFlowTypeOfDestructuring(declaration, declaredType);
|
|
}
|
|
} else {
|
|
const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */ | (declaration.dotDotDotToken ? 0 : 128 /* PossiblyOutOfBounds */), parentType, undefinedType, pattern);
|
|
const index = pattern.elements.indexOf(declaration);
|
|
if (declaration.dotDotDotToken) {
|
|
type = everyType(parentType, isTupleType) ? mapType(parentType, (t) => sliceTupleType(t, index)) : createArrayType(elementType);
|
|
} else if (isArrayLikeType(parentType)) {
|
|
const indexType = getNumberLiteralType(index);
|
|
const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(declaration) ? 16 /* NoTupleBoundsCheck */ : 0);
|
|
const declaredType = getIndexedAccessTypeOrUndefined(parentType, indexType, accessFlags, declaration.name) || errorType;
|
|
type = getFlowTypeOfDestructuring(declaration, declaredType);
|
|
} else {
|
|
type = elementType;
|
|
}
|
|
}
|
|
if (!declaration.initializer) {
|
|
return type;
|
|
}
|
|
if (getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration))) {
|
|
return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
|
|
}
|
|
return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
|
|
}
|
|
function getTypeForDeclarationFromJSDocComment(declaration) {
|
|
const jsdocType = getJSDocType(declaration);
|
|
if (jsdocType) {
|
|
return getTypeFromTypeNode(jsdocType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isNullOrUndefined2(node) {
|
|
const expr = skipParentheses(node, true);
|
|
return expr.kind === 104 /* NullKeyword */ || expr.kind === 79 /* Identifier */ && getResolvedSymbol(expr) === undefinedSymbol;
|
|
}
|
|
function isEmptyArrayLiteral2(node) {
|
|
const expr = skipParentheses(node, true);
|
|
return expr.kind === 206 /* ArrayLiteralExpression */ && expr.elements.length === 0;
|
|
}
|
|
function addOptionality(type, isProperty = false, isOptional = true) {
|
|
return strictNullChecks && isOptional ? getOptionalType(type, isProperty) : type;
|
|
}
|
|
function getTypeForVariableLikeDeclaration(declaration, includeOptionality, checkMode) {
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 246 /* ForInStatement */) {
|
|
const indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression, checkMode)));
|
|
return indexType.flags & (262144 /* TypeParameter */ | 4194304 /* Index */) ? getExtractStringType(indexType) : stringType;
|
|
}
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
const forOfStatement = declaration.parent.parent;
|
|
return checkRightHandSideOfForOf(forOfStatement) || anyType;
|
|
}
|
|
if (isBindingPattern(declaration.parent)) {
|
|
return getTypeForBindingElement(declaration);
|
|
}
|
|
const isProperty = isPropertyDeclaration(declaration) && !hasAccessorModifier(declaration) || isPropertySignature(declaration);
|
|
const isOptional = includeOptionality && (isProperty && !!declaration.questionToken || isParameter(declaration) && (!!declaration.questionToken || isJSDocOptionalParameter(declaration)) || isOptionalJSDocPropertyLikeTag(declaration));
|
|
const declaredType = tryGetTypeFromEffectiveTypeNode(declaration);
|
|
if (declaredType) {
|
|
return addOptionality(declaredType, isProperty, isOptional);
|
|
}
|
|
if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlags(declaration) & 1 /* Export */) && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
if (!(getCombinedNodeFlags(declaration) & 2 /* Const */) && (!declaration.initializer || isNullOrUndefined2(declaration.initializer))) {
|
|
return autoType;
|
|
}
|
|
if (declaration.initializer && isEmptyArrayLiteral2(declaration.initializer)) {
|
|
return autoArrayType;
|
|
}
|
|
}
|
|
if (isParameter(declaration)) {
|
|
const func = declaration.parent;
|
|
if (func.kind === 175 /* SetAccessor */ && hasBindableName(func)) {
|
|
const getter = getDeclarationOfKind(getSymbolOfNode(declaration.parent), 174 /* GetAccessor */);
|
|
if (getter) {
|
|
const getterSignature = getSignatureFromDeclaration(getter);
|
|
const thisParameter = getAccessorThisParameter(func);
|
|
if (thisParameter && declaration === thisParameter) {
|
|
Debug.assert(!thisParameter.type);
|
|
return getTypeOfSymbol(getterSignature.thisParameter);
|
|
}
|
|
return getReturnTypeOfSignature(getterSignature);
|
|
}
|
|
}
|
|
const parameterTypeOfTypeTag = getParameterTypeOfTypeTag(func, declaration);
|
|
if (parameterTypeOfTypeTag)
|
|
return parameterTypeOfTypeTag;
|
|
const type = declaration.symbol.escapedName === "this" /* This */ ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
|
|
if (type) {
|
|
return addOptionality(type, false, isOptional);
|
|
}
|
|
}
|
|
if (hasOnlyExpressionInitializer(declaration) && !!declaration.initializer) {
|
|
if (isInJSFile(declaration) && !isParameter(declaration)) {
|
|
const containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), getDeclaredExpandoInitializer(declaration));
|
|
if (containerObjectType) {
|
|
return containerObjectType;
|
|
}
|
|
}
|
|
const type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, checkMode));
|
|
return addOptionality(type, isProperty, isOptional);
|
|
}
|
|
if (isPropertyDeclaration(declaration) && (noImplicitAny || isInJSFile(declaration))) {
|
|
if (!hasStaticModifier(declaration)) {
|
|
const constructor = findConstructorDeclaration(declaration.parent);
|
|
const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
|
|
return type && addOptionality(type, true, isOptional);
|
|
} else {
|
|
const staticBlocks = filter(declaration.parent.members, isClassStaticBlockDeclaration);
|
|
const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
|
|
return type && addOptionality(type, true, isOptional);
|
|
}
|
|
}
|
|
if (isJsxAttribute(declaration)) {
|
|
return trueType;
|
|
}
|
|
if (isBindingPattern(declaration.name)) {
|
|
return getTypeFromBindingPattern(declaration.name, false, true);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isConstructorDeclaredProperty(symbol) {
|
|
if (symbol.valueDeclaration && isBinaryExpression(symbol.valueDeclaration)) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.isConstructorDeclaredProperty === void 0) {
|
|
links.isConstructorDeclaredProperty = false;
|
|
links.isConstructorDeclaredProperty = !!getDeclaringConstructor(symbol) && every(symbol.declarations, (declaration) => isBinaryExpression(declaration) && isPossiblyAliasedThisProperty(declaration) && (declaration.left.kind !== 209 /* ElementAccessExpression */ || isStringOrNumericLiteralLike(declaration.left.argumentExpression)) && !getAnnotatedTypeForAssignmentDeclaration(void 0, declaration, symbol, declaration));
|
|
}
|
|
return links.isConstructorDeclaredProperty;
|
|
}
|
|
return false;
|
|
}
|
|
function isAutoTypedProperty(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
return declaration && isPropertyDeclaration(declaration) && !getEffectiveTypeAnnotationNode(declaration) && !declaration.initializer && (noImplicitAny || isInJSFile(declaration));
|
|
}
|
|
function getDeclaringConstructor(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
const container = getThisContainer(declaration, false);
|
|
if (container && (container.kind === 173 /* Constructor */ || isJSConstructor(container))) {
|
|
return container;
|
|
}
|
|
}
|
|
}
|
|
function getFlowTypeFromCommonJSExport(symbol) {
|
|
const file = getSourceFileOfNode(symbol.declarations[0]);
|
|
const accessName = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const areAllModuleExports = symbol.declarations.every((d) => isInJSFile(d) && isAccessExpression(d) && isModuleExportsAccessExpression(d.expression));
|
|
const reference = areAllModuleExports ? factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("module"), factory.createIdentifier("exports")), accessName) : factory.createPropertyAccessExpression(factory.createIdentifier("exports"), accessName);
|
|
if (areAllModuleExports) {
|
|
setParent(reference.expression.expression, reference.expression);
|
|
}
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, file);
|
|
reference.flowNode = file.endFlowNode;
|
|
return getFlowTypeOfReference(reference, autoType, undefinedType);
|
|
}
|
|
function getFlowTypeInStaticBlocks(symbol, staticBlocks) {
|
|
const accessName = startsWith(symbol.escapedName, "__#") ? factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) : unescapeLeadingUnderscores(symbol.escapedName);
|
|
for (const staticBlock of staticBlocks) {
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), accessName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, staticBlock);
|
|
reference.flowNode = staticBlock.returnFlowNode;
|
|
const flowType = getFlowTypeOfProperty(reference, symbol);
|
|
if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) {
|
|
error(symbol.valueDeclaration, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
if (everyType(flowType, isNullableType)) {
|
|
continue;
|
|
}
|
|
return convertAutoToAny(flowType);
|
|
}
|
|
}
|
|
function getFlowTypeInConstructor(symbol, constructor) {
|
|
const accessName = startsWith(symbol.escapedName, "__#") ? factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) : unescapeLeadingUnderscores(symbol.escapedName);
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), accessName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, constructor);
|
|
reference.flowNode = constructor.returnFlowNode;
|
|
const flowType = getFlowTypeOfProperty(reference, symbol);
|
|
if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) {
|
|
error(symbol.valueDeclaration, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
return everyType(flowType, isNullableType) ? void 0 : convertAutoToAny(flowType);
|
|
}
|
|
function getFlowTypeOfProperty(reference, prop) {
|
|
const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 2 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
|
|
return getFlowTypeOfReference(reference, autoType, initialType);
|
|
}
|
|
function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
|
|
const container = getAssignedExpandoInitializer(symbol.valueDeclaration);
|
|
if (container) {
|
|
const tag = getJSDocTypeTag(container);
|
|
if (tag && tag.typeExpression) {
|
|
return getTypeFromTypeNode(tag.typeExpression);
|
|
}
|
|
const containerObjectType = symbol.valueDeclaration && getJSContainerObjectType(symbol.valueDeclaration, symbol, container);
|
|
return containerObjectType || getWidenedLiteralType(checkExpressionCached(container));
|
|
}
|
|
let type;
|
|
let definedInConstructor = false;
|
|
let definedInMethod = false;
|
|
if (isConstructorDeclaredProperty(symbol)) {
|
|
type = getFlowTypeInConstructor(symbol, getDeclaringConstructor(symbol));
|
|
}
|
|
if (!type) {
|
|
let types;
|
|
if (symbol.declarations) {
|
|
let jsdocType;
|
|
for (const declaration of symbol.declarations) {
|
|
const expression = isBinaryExpression(declaration) || isCallExpression(declaration) ? declaration : isAccessExpression(declaration) ? isBinaryExpression(declaration.parent) ? declaration.parent : declaration : void 0;
|
|
if (!expression) {
|
|
continue;
|
|
}
|
|
const kind = isAccessExpression(expression) ? getAssignmentDeclarationPropertyAccessKind(expression) : getAssignmentDeclarationKind(expression);
|
|
if (kind === 4 /* ThisProperty */ || isBinaryExpression(expression) && isPossiblyAliasedThisProperty(expression, kind)) {
|
|
if (isDeclarationInConstructor(expression)) {
|
|
definedInConstructor = true;
|
|
} else {
|
|
definedInMethod = true;
|
|
}
|
|
}
|
|
if (!isCallExpression(expression)) {
|
|
jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration);
|
|
}
|
|
if (!jsdocType) {
|
|
(types || (types = [])).push(isBinaryExpression(expression) || isCallExpression(expression) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
|
|
}
|
|
}
|
|
type = jsdocType;
|
|
}
|
|
if (!type) {
|
|
if (!length(types)) {
|
|
return errorType;
|
|
}
|
|
let constructorTypes = definedInConstructor && symbol.declarations ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : void 0;
|
|
if (definedInMethod) {
|
|
const propType = getTypeOfPropertyInBaseClass(symbol);
|
|
if (propType) {
|
|
(constructorTypes || (constructorTypes = [])).push(propType);
|
|
definedInConstructor = true;
|
|
}
|
|
}
|
|
const sourceTypes = some(constructorTypes, (t) => !!(t.flags & ~98304 /* Nullable */)) ? constructorTypes : types;
|
|
type = getUnionType(sourceTypes);
|
|
}
|
|
}
|
|
const widened = getWidenedType(addOptionality(type, false, definedInMethod && !definedInConstructor));
|
|
if (symbol.valueDeclaration && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
|
|
reportImplicitAny(symbol.valueDeclaration, anyType);
|
|
return anyType;
|
|
}
|
|
return widened;
|
|
}
|
|
function getJSContainerObjectType(decl, symbol, init) {
|
|
var _a2, _b;
|
|
if (!isInJSFile(decl) || !init || !isObjectLiteralExpression(init) || init.properties.length) {
|
|
return void 0;
|
|
}
|
|
const exports = createSymbolTable();
|
|
while (isBinaryExpression(decl) || isPropertyAccessExpression(decl)) {
|
|
const s2 = getSymbolOfNode(decl);
|
|
if ((_a2 = s2 == null ? void 0 : s2.exports) == null ? void 0 : _a2.size) {
|
|
mergeSymbolTable(exports, s2.exports);
|
|
}
|
|
decl = isBinaryExpression(decl) ? decl.parent : decl.parent.parent;
|
|
}
|
|
const s = getSymbolOfNode(decl);
|
|
if ((_b = s == null ? void 0 : s.exports) == null ? void 0 : _b.size) {
|
|
mergeSymbolTable(exports, s.exports);
|
|
}
|
|
const type = createAnonymousType(symbol, exports, emptyArray, emptyArray, emptyArray);
|
|
type.objectFlags |= 4096 /* JSLiteral */;
|
|
return type;
|
|
}
|
|
function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) {
|
|
var _a2;
|
|
const typeNode = getEffectiveTypeAnnotationNode(expression.parent);
|
|
if (typeNode) {
|
|
const type = getWidenedType(getTypeFromTypeNode(typeNode));
|
|
if (!declaredType) {
|
|
return type;
|
|
} else if (!isErrorType(declaredType) && !isErrorType(type) && !isTypeIdenticalTo(declaredType, type)) {
|
|
errorNextVariableOrPropertyDeclarationMustHaveSameType(void 0, declaredType, declaration, type);
|
|
}
|
|
}
|
|
if ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) {
|
|
const typeNode2 = getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration);
|
|
if (typeNode2) {
|
|
const annotationSymbol = getPropertyOfType(getTypeFromTypeNode(typeNode2), symbol.escapedName);
|
|
if (annotationSymbol) {
|
|
return getNonMissingTypeOfSymbol(annotationSymbol);
|
|
}
|
|
}
|
|
}
|
|
return declaredType;
|
|
}
|
|
function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) {
|
|
if (isCallExpression(expression)) {
|
|
if (resolvedSymbol) {
|
|
return getTypeOfSymbol(resolvedSymbol);
|
|
}
|
|
const objectLitType = checkExpressionCached(expression.arguments[2]);
|
|
const valueType = getTypeOfPropertyOfType(objectLitType, "value");
|
|
if (valueType) {
|
|
return valueType;
|
|
}
|
|
const getFunc = getTypeOfPropertyOfType(objectLitType, "get");
|
|
if (getFunc) {
|
|
const getSig = getSingleCallSignature(getFunc);
|
|
if (getSig) {
|
|
return getReturnTypeOfSignature(getSig);
|
|
}
|
|
}
|
|
const setFunc = getTypeOfPropertyOfType(objectLitType, "set");
|
|
if (setFunc) {
|
|
const setSig = getSingleCallSignature(setFunc);
|
|
if (setSig) {
|
|
return getTypeOfFirstParameterOfSignature(setSig);
|
|
}
|
|
}
|
|
return anyType;
|
|
}
|
|
if (containsSameNamedThisProperty(expression.left, expression.right)) {
|
|
return anyType;
|
|
}
|
|
const isDirectExport = kind === 1 /* ExportsProperty */ && (isPropertyAccessExpression(expression.left) || isElementAccessExpression(expression.left)) && (isModuleExportsAccessExpression(expression.left.expression) || isIdentifier(expression.left.expression) && isExportsIdentifier(expression.left.expression));
|
|
const type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : isDirectExport ? getRegularTypeOfLiteralType(checkExpressionCached(expression.right)) : getWidenedLiteralType(checkExpressionCached(expression.right));
|
|
if (type.flags & 524288 /* Object */ && kind === 2 /* ModuleExports */ && symbol.escapedName === "export=" /* ExportEquals */) {
|
|
const exportedType = resolveStructuredTypeMembers(type);
|
|
const members = createSymbolTable();
|
|
copyEntries(exportedType.members, members);
|
|
const initialSize = members.size;
|
|
if (resolvedSymbol && !resolvedSymbol.exports) {
|
|
resolvedSymbol.exports = createSymbolTable();
|
|
}
|
|
(resolvedSymbol || symbol).exports.forEach((s, name) => {
|
|
var _a2;
|
|
const exportedMember = members.get(name);
|
|
if (exportedMember && exportedMember !== s && !(s.flags & 2097152 /* Alias */)) {
|
|
if (s.flags & 111551 /* Value */ && exportedMember.flags & 111551 /* Value */) {
|
|
if (s.valueDeclaration && exportedMember.valueDeclaration && getSourceFileOfNode(s.valueDeclaration) !== getSourceFileOfNode(exportedMember.valueDeclaration)) {
|
|
const unescapedName = unescapeLeadingUnderscores(s.escapedName);
|
|
const exportedMemberName = ((_a2 = tryCast(exportedMember.valueDeclaration, isNamedDeclaration)) == null ? void 0 : _a2.name) || exportedMember.valueDeclaration;
|
|
addRelatedInfo(
|
|
error(s.valueDeclaration, Diagnostics.Duplicate_identifier_0, unescapedName),
|
|
createDiagnosticForNode(exportedMemberName, Diagnostics._0_was_also_declared_here, unescapedName)
|
|
);
|
|
addRelatedInfo(
|
|
error(exportedMemberName, Diagnostics.Duplicate_identifier_0, unescapedName),
|
|
createDiagnosticForNode(s.valueDeclaration, Diagnostics._0_was_also_declared_here, unescapedName)
|
|
);
|
|
}
|
|
const union = createSymbol(s.flags | exportedMember.flags, name);
|
|
union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]);
|
|
union.valueDeclaration = exportedMember.valueDeclaration;
|
|
union.declarations = concatenate(exportedMember.declarations, s.declarations);
|
|
members.set(name, union);
|
|
} else {
|
|
members.set(name, mergeSymbol(s, exportedMember));
|
|
}
|
|
} else {
|
|
members.set(name, s);
|
|
}
|
|
});
|
|
const result = createAnonymousType(
|
|
initialSize !== members.size ? void 0 : exportedType.symbol,
|
|
members,
|
|
exportedType.callSignatures,
|
|
exportedType.constructSignatures,
|
|
exportedType.indexInfos
|
|
);
|
|
if (initialSize === members.size) {
|
|
if (type.aliasSymbol) {
|
|
result.aliasSymbol = type.aliasSymbol;
|
|
result.aliasTypeArguments = type.aliasTypeArguments;
|
|
}
|
|
if (getObjectFlags(type) & 4 /* Reference */) {
|
|
result.aliasSymbol = type.symbol;
|
|
const args = getTypeArguments(type);
|
|
result.aliasTypeArguments = length(args) ? args : void 0;
|
|
}
|
|
}
|
|
result.objectFlags |= getObjectFlags(type) & 4096 /* JSLiteral */;
|
|
if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
|
|
result.objectFlags |= 16777216 /* IsClassInstanceClone */;
|
|
}
|
|
return result;
|
|
}
|
|
if (isEmptyArrayLiteralType(type)) {
|
|
reportImplicitAny(expression, anyArrayType);
|
|
return anyArrayType;
|
|
}
|
|
return type;
|
|
}
|
|
function containsSameNamedThisProperty(thisProperty, expression) {
|
|
return isPropertyAccessExpression(thisProperty) && thisProperty.expression.kind === 108 /* ThisKeyword */ && forEachChildRecursively(expression, (n) => isMatchingReference(thisProperty, n));
|
|
}
|
|
function isDeclarationInConstructor(expression) {
|
|
const thisContainer = getThisContainer(expression, false);
|
|
return thisContainer.kind === 173 /* Constructor */ || thisContainer.kind === 259 /* FunctionDeclaration */ || thisContainer.kind === 215 /* FunctionExpression */ && !isPrototypePropertyAssignment(thisContainer.parent);
|
|
}
|
|
function getConstructorDefinedThisAssignmentTypes(types, declarations) {
|
|
Debug.assert(types.length === declarations.length);
|
|
return types.filter((_, i) => {
|
|
const declaration = declarations[i];
|
|
const expression = isBinaryExpression(declaration) ? declaration : isBinaryExpression(declaration.parent) ? declaration.parent : void 0;
|
|
return expression && isDeclarationInConstructor(expression);
|
|
});
|
|
}
|
|
function getTypeFromBindingElement(element, includePatternInType, reportErrors2) {
|
|
if (element.initializer) {
|
|
const contextualType = isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType;
|
|
return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
|
|
}
|
|
if (isBindingPattern(element.name)) {
|
|
return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2);
|
|
}
|
|
if (reportErrors2 && !declarationBelongsToPrivateAmbientMember(element)) {
|
|
reportImplicitAny(element, anyType);
|
|
}
|
|
return includePatternInType ? nonInferrableAnyType : anyType;
|
|
}
|
|
function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors2) {
|
|
const members = createSymbolTable();
|
|
let stringIndexInfo;
|
|
let objectFlags = 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
forEach(pattern.elements, (e) => {
|
|
const name = e.propertyName || e.name;
|
|
if (e.dotDotDotToken) {
|
|
stringIndexInfo = createIndexInfo(stringType, anyType, false);
|
|
return;
|
|
}
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (!isTypeUsableAsPropertyName(exprType)) {
|
|
objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
|
|
return;
|
|
}
|
|
const text = getPropertyNameFromType(exprType);
|
|
const flags = 4 /* Property */ | (e.initializer ? 16777216 /* Optional */ : 0);
|
|
const symbol = createSymbol(flags, text);
|
|
symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors2);
|
|
symbol.bindingElement = e;
|
|
members.set(symbol.escapedName, symbol);
|
|
});
|
|
const result = createAnonymousType(void 0, members, emptyArray, emptyArray, stringIndexInfo ? [stringIndexInfo] : emptyArray);
|
|
result.objectFlags |= objectFlags;
|
|
if (includePatternInType) {
|
|
result.pattern = pattern;
|
|
result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors2) {
|
|
const elements = pattern.elements;
|
|
const lastElement = lastOrUndefined(elements);
|
|
const restElement = lastElement && lastElement.kind === 205 /* BindingElement */ && lastElement.dotDotDotToken ? lastElement : void 0;
|
|
if (elements.length === 0 || elements.length === 1 && restElement) {
|
|
return languageVersion >= 2 /* ES2015 */ ? createIterableType(anyType) : anyArrayType;
|
|
}
|
|
const elementTypes = map(elements, (e) => isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors2));
|
|
const minLength = findLastIndex(elements, (e) => !(e === restElement || isOmittedExpression(e) || hasDefaultValue(e)), elements.length - 1) + 1;
|
|
const elementFlags = map(elements, (e, i) => e === restElement ? 4 /* Rest */ : i >= minLength ? 2 /* Optional */ : 1 /* Required */);
|
|
let result = createTupleType(elementTypes, elementFlags);
|
|
if (includePatternInType) {
|
|
result = cloneTypeReference(result);
|
|
result.pattern = pattern;
|
|
result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeFromBindingPattern(pattern, includePatternInType = false, reportErrors2 = false) {
|
|
return pattern.kind === 203 /* ObjectBindingPattern */ ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors2) : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors2);
|
|
}
|
|
function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors2) {
|
|
return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, true, 0 /* Normal */), declaration, reportErrors2);
|
|
}
|
|
function isGlobalSymbolConstructor(node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const globalSymbol = getGlobalESSymbolConstructorTypeSymbol(false);
|
|
return globalSymbol && symbol && symbol === globalSymbol;
|
|
}
|
|
function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors2) {
|
|
if (type) {
|
|
if (type.flags & 4096 /* ESSymbol */ && isGlobalSymbolConstructor(declaration.parent)) {
|
|
type = getESSymbolLikeTypeForNode(declaration);
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorsFromWidening(declaration, type);
|
|
}
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && (isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) {
|
|
type = esSymbolType;
|
|
}
|
|
return getWidenedType(type);
|
|
}
|
|
type = isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType;
|
|
if (reportErrors2) {
|
|
if (!declarationBelongsToPrivateAmbientMember(declaration)) {
|
|
reportImplicitAny(declaration, type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function declarationBelongsToPrivateAmbientMember(declaration) {
|
|
const root = getRootDeclaration(declaration);
|
|
const memberDeclaration = root.kind === 166 /* Parameter */ ? root.parent : root;
|
|
return isPrivateWithinAmbient(memberDeclaration);
|
|
}
|
|
function tryGetTypeFromEffectiveTypeNode(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
}
|
|
function isParameterOfContextSensitiveSignature(symbol) {
|
|
let decl = symbol.valueDeclaration;
|
|
if (!decl) {
|
|
return false;
|
|
}
|
|
if (isBindingElement(decl)) {
|
|
decl = walkUpBindingElementsAndPatterns(decl);
|
|
}
|
|
if (isParameter(decl)) {
|
|
return isContextSensitiveFunctionOrObjectLiteralMethod(decl.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function getTypeOfVariableOrParameterOrProperty(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
|
|
if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
|
|
links.type = type;
|
|
}
|
|
return type;
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
|
|
if (symbol.flags & 4194304 /* Prototype */) {
|
|
return getTypeOfPrototypeProperty(symbol);
|
|
}
|
|
if (symbol === requireSymbol) {
|
|
return anyType;
|
|
}
|
|
if (symbol.flags & 134217728 /* ModuleExports */ && symbol.valueDeclaration) {
|
|
const fileSymbol = getSymbolOfNode(getSourceFileOfNode(symbol.valueDeclaration));
|
|
const 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 Map(fileSymbol.members);
|
|
if (fileSymbol.exports)
|
|
result.exports = new Map(fileSymbol.exports);
|
|
const members = createSymbolTable();
|
|
members.set("exports", result);
|
|
return createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
Debug.assertIsDefined(symbol.valueDeclaration);
|
|
const declaration = symbol.valueDeclaration;
|
|
if (isCatchClauseVariableDeclarationOrBindingElement(declaration)) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(declaration);
|
|
if (typeNode === void 0) {
|
|
return useUnknownInCatchVariables ? unknownType : anyType;
|
|
}
|
|
const type2 = getTypeOfNode(typeNode);
|
|
return isTypeAny(type2) || type2 === unknownType ? type2 : errorType;
|
|
}
|
|
if (isSourceFile(declaration) && isJsonSourceFile(declaration)) {
|
|
if (!declaration.statements.length) {
|
|
return emptyObjectType;
|
|
}
|
|
return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
|
|
}
|
|
if (isAccessor(declaration)) {
|
|
return getTypeOfAccessors(symbol);
|
|
}
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
return reportCircularityError(symbol);
|
|
}
|
|
let type;
|
|
if (declaration.kind === 274 /* ExportAssignment */) {
|
|
type = widenTypeForVariableLikeDeclaration(tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionCached(declaration.expression), declaration);
|
|
} else if (isBinaryExpression(declaration) || isInJSFile(declaration) && (isCallExpression(declaration) || (isPropertyAccessExpression(declaration) || isBindableStaticElementAccessExpression(declaration)) && isBinaryExpression(declaration.parent))) {
|
|
type = getWidenedTypeForAssignmentDeclaration(symbol);
|
|
} else if (isPropertyAccessExpression(declaration) || isElementAccessExpression(declaration) || isIdentifier(declaration) || isStringLiteralLike(declaration) || isNumericLiteral(declaration) || isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isMethodDeclaration(declaration) && !isObjectLiteralMethod(declaration) || isMethodSignature(declaration) || isSourceFile(declaration)) {
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
type = isBinaryExpression(declaration.parent) ? getWidenedTypeForAssignmentDeclaration(symbol) : tryGetTypeFromEffectiveTypeNode(declaration) || anyType;
|
|
} else if (isPropertyAssignment(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration);
|
|
} else if (isJsxAttribute(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration);
|
|
} else if (isShorthandPropertyAssignment(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0 /* Normal */);
|
|
} else if (isObjectLiteralMethod(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0 /* Normal */);
|
|
} else if (isParameter(declaration) || isPropertyDeclaration(declaration) || isPropertySignature(declaration) || isVariableDeclaration(declaration) || isBindingElement(declaration) || isJSDocPropertyLikeTag(declaration)) {
|
|
type = getWidenedTypeForVariableLikeDeclaration(declaration, true);
|
|
} else if (isEnumDeclaration(declaration)) {
|
|
type = getTypeOfFuncClassEnumModule(symbol);
|
|
} else if (isEnumMember(declaration)) {
|
|
type = getTypeOfEnumMember(symbol);
|
|
} else {
|
|
return Debug.fail("Unhandled declaration kind! " + Debug.formatSyntaxKind(declaration.kind) + " for " + Debug.formatSymbol(symbol));
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
return reportCircularityError(symbol);
|
|
}
|
|
return type;
|
|
}
|
|
function getAnnotatedAccessorTypeNode(accessor) {
|
|
if (accessor) {
|
|
switch (accessor.kind) {
|
|
case 174 /* GetAccessor */:
|
|
const getterTypeAnnotation = getEffectiveReturnTypeNode(accessor);
|
|
return getterTypeAnnotation;
|
|
case 175 /* SetAccessor */:
|
|
const setterTypeAnnotation = getEffectiveSetAccessorTypeAnnotationNode(accessor);
|
|
return setterTypeAnnotation;
|
|
case 169 /* PropertyDeclaration */:
|
|
Debug.assert(hasAccessorModifier(accessor));
|
|
const accessorTypeAnnotation = getEffectiveTypeAnnotationNode(accessor);
|
|
return accessorTypeAnnotation;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAnnotatedAccessorType(accessor) {
|
|
const node = getAnnotatedAccessorTypeNode(accessor);
|
|
return node && getTypeFromTypeNode(node);
|
|
}
|
|
function getAnnotatedAccessorThisParameter(accessor) {
|
|
const parameter = getAccessorThisParameter(accessor);
|
|
return parameter && parameter.symbol;
|
|
}
|
|
function getThisTypeOfDeclaration(declaration) {
|
|
return getThisTypeOfSignature(getSignatureFromDeclaration(declaration));
|
|
}
|
|
function getTypeOfAccessors(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
return errorType;
|
|
}
|
|
const getter = getDeclarationOfKind(symbol, 174 /* GetAccessor */);
|
|
const setter = getDeclarationOfKind(symbol, 175 /* SetAccessor */);
|
|
const accessor = tryCast(getDeclarationOfKind(symbol, 169 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
|
|
let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(accessor, true);
|
|
if (!type) {
|
|
if (setter && !isPrivateWithinAmbient(setter)) {
|
|
errorOrSuggestion(noImplicitAny, setter, 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, 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, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), "any");
|
|
}
|
|
type = anyType;
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (getAnnotatedAccessorTypeNode(getter)) {
|
|
error(getter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getAnnotatedAccessorTypeNode(setter)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getAnnotatedAccessorTypeNode(accessor)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getter && noImplicitAny) {
|
|
error(getter, 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 _a2;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.writeType) {
|
|
if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
|
|
return errorType;
|
|
}
|
|
const setter = (_a2 = getDeclarationOfKind(symbol, 175 /* SetAccessor */)) != null ? _a2 : tryCast(getDeclarationOfKind(symbol, 169 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
|
|
let writeType = getAnnotatedAccessorType(setter);
|
|
if (!popTypeResolution()) {
|
|
if (getAnnotatedAccessorTypeNode(setter)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
}
|
|
writeType = anyType;
|
|
}
|
|
links.writeType = writeType || getTypeOfAccessors(symbol);
|
|
}
|
|
return links.writeType;
|
|
}
|
|
function getBaseTypeVariableOfClass(symbol) {
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
|
|
return baseConstructorType.flags & 8650752 /* TypeVariable */ ? baseConstructorType : baseConstructorType.flags & 2097152 /* Intersection */ ? find(baseConstructorType.types, (t) => !!(t.flags & 8650752 /* TypeVariable */)) : void 0;
|
|
}
|
|
function getTypeOfFuncClassEnumModule(symbol) {
|
|
let links = getSymbolLinks(symbol);
|
|
const originalLinks = links;
|
|
if (!links.type) {
|
|
const expando = symbol.valueDeclaration && getSymbolOfExpando(symbol.valueDeclaration, false);
|
|
if (expando) {
|
|
const merged = mergeJSSymbols(symbol, expando);
|
|
if (merged) {
|
|
symbol = links = merged;
|
|
}
|
|
}
|
|
originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol);
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfFuncClassEnumModuleWorker(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (symbol.flags & 1536 /* Module */ && isShorthandAmbientModuleSymbol(symbol)) {
|
|
return anyType;
|
|
} else if (declaration && (declaration.kind === 223 /* BinaryExpression */ || isAccessExpression(declaration) && declaration.parent.kind === 223 /* BinaryExpression */)) {
|
|
return getWidenedTypeForAssignmentDeclaration(symbol);
|
|
} else if (symbol.flags & 512 /* ValueModule */ && declaration && isSourceFile(declaration) && declaration.commonJsModuleIndicator) {
|
|
const resolvedModule = resolveExternalModuleSymbol(symbol);
|
|
if (resolvedModule !== symbol) {
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
return errorType;
|
|
}
|
|
const exportEquals = getMergedSymbol(symbol.exports.get("export=" /* ExportEquals */));
|
|
const type2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? void 0 : resolvedModule);
|
|
if (!popTypeResolution()) {
|
|
return reportCircularityError(symbol);
|
|
}
|
|
return type2;
|
|
}
|
|
}
|
|
const type = createObjectType(16 /* Anonymous */, symbol);
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
|
|
return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
|
|
} else {
|
|
return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(type) : type;
|
|
}
|
|
}
|
|
function getTypeOfEnumMember(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol));
|
|
}
|
|
function getTypeOfAlias(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
const targetSymbol = resolveAlias(symbol);
|
|
const exportSymbol = symbol.declarations && getTargetOfAliasDeclaration(getDeclarationOfAliasSymbol(symbol), true);
|
|
const declaredType = firstDefined(exportSymbol == null ? void 0 : exportSymbol.declarations, (d) => isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : void 0);
|
|
links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getAllSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfInstantiatedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper));
|
|
}
|
|
function getWriteTypeOfInstantiatedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target), links.mapper));
|
|
}
|
|
function reportCircularityError(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (getEffectiveTypeAnnotationNode(declaration)) {
|
|
error(
|
|
symbol.valueDeclaration,
|
|
Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation,
|
|
symbolToString(symbol)
|
|
);
|
|
return errorType;
|
|
}
|
|
if (noImplicitAny && (declaration.kind !== 166 /* Parameter */ || declaration.initializer)) {
|
|
error(
|
|
symbol.valueDeclaration,
|
|
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)
|
|
);
|
|
}
|
|
return anyType;
|
|
}
|
|
function getTypeOfSymbolWithDeferredType(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
Debug.assertIsDefined(links.deferralParent);
|
|
Debug.assertIsDefined(links.deferralConstituents);
|
|
links.type = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
|
|
}
|
|
return links.type;
|
|
}
|
|
function getWriteTypeOfSymbolWithDeferredType(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.writeType && links.deferralWriteConstituents) {
|
|
Debug.assertIsDefined(links.deferralParent);
|
|
Debug.assertIsDefined(links.deferralConstituents);
|
|
links.writeType = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents);
|
|
}
|
|
return links.writeType;
|
|
}
|
|
function getWriteTypeOfSymbol(symbol) {
|
|
const checkFlags = getCheckFlags(symbol);
|
|
if (symbol.flags & 4 /* Property */) {
|
|
return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : symbol.writeType || symbol.type : getTypeOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & 98304 /* Accessor */) {
|
|
return checkFlags & 1 /* Instantiated */ ? getWriteTypeOfInstantiatedSymbol(symbol) : getWriteTypeOfAccessors(symbol);
|
|
}
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
function getTypeOfSymbol(symbol) {
|
|
const checkFlags = getCheckFlags(symbol);
|
|
if (checkFlags & 65536 /* DeferredType */) {
|
|
return getTypeOfSymbolWithDeferredType(symbol);
|
|
}
|
|
if (checkFlags & 1 /* Instantiated */) {
|
|
return getTypeOfInstantiatedSymbol(symbol);
|
|
}
|
|
if (checkFlags & 262144 /* Mapped */) {
|
|
return getTypeOfMappedSymbol(symbol);
|
|
}
|
|
if (checkFlags & 8192 /* ReverseMapped */) {
|
|
return getTypeOfReverseMappedSymbol(symbol);
|
|
}
|
|
if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
|
|
return getTypeOfVariableOrParameterOrProperty(symbol);
|
|
}
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return getTypeOfEnumMember(symbol);
|
|
}
|
|
if (symbol.flags & 98304 /* Accessor */) {
|
|
return getTypeOfAccessors(symbol);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
return getTypeOfAlias(symbol);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getNonMissingTypeOfSymbol(symbol) {
|
|
return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & 16777216 /* Optional */));
|
|
}
|
|
function isReferenceToType(type, target) {
|
|
return type !== void 0 && target !== void 0 && (getObjectFlags(type) & 4 /* Reference */) !== 0 && type.target === target;
|
|
}
|
|
function getTargetType(type) {
|
|
return getObjectFlags(type) & 4 /* Reference */ ? type.target : type;
|
|
}
|
|
function hasBaseType(type, checkBase) {
|
|
return check(type);
|
|
function check(type2) {
|
|
if (getObjectFlags(type2) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
|
|
const target = getTargetType(type2);
|
|
return target === checkBase || some(getBaseTypes(target), check);
|
|
} else if (type2.flags & 2097152 /* Intersection */) {
|
|
return some(type2.types, check);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function appendTypeParameters(typeParameters, declarations) {
|
|
for (const declaration of declarations) {
|
|
typeParameters = appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration)));
|
|
}
|
|
return typeParameters;
|
|
}
|
|
function getOuterTypeParameters(node, includeThisTypes) {
|
|
while (true) {
|
|
node = node.parent;
|
|
if (node && isBinaryExpression(node)) {
|
|
const assignmentKind = getAssignmentDeclarationKind(node);
|
|
if (assignmentKind === 6 /* Prototype */ || assignmentKind === 3 /* PrototypeProperty */) {
|
|
const symbol = getSymbolOfNode(node.left);
|
|
if (symbol && symbol.parent && !findAncestor(symbol.parent.valueDeclaration, (d) => node === d)) {
|
|
node = symbol.parent.valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 347 /* JSDocTemplateTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 197 /* MappedType */:
|
|
case 191 /* ConditionalType */: {
|
|
const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
|
|
if (node.kind === 197 /* MappedType */) {
|
|
return append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)));
|
|
} else if (node.kind === 191 /* ConditionalType */) {
|
|
return concatenate(outerTypeParameters, getInferTypeParameters(node));
|
|
}
|
|
const outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(node));
|
|
const thisType = includeThisTypes && (node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */ || node.kind === 261 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType;
|
|
return thisType ? append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
|
|
}
|
|
case 343 /* JSDocParameterTag */:
|
|
const paramSymbol = getParameterSymbolFromJSDoc(node);
|
|
if (paramSymbol) {
|
|
node = paramSymbol.valueDeclaration;
|
|
}
|
|
break;
|
|
case 323 /* JSDoc */: {
|
|
const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
|
|
return node.tags ? appendTypeParameters(outerTypeParameters, flatMap(node.tags, (t) => isJSDocTemplateTag(t) ? t.typeParameters : void 0)) : outerTypeParameters;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getOuterTypeParametersOfClassOrInterface(symbol) {
|
|
const declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : getDeclarationOfKind(symbol, 261 /* InterfaceDeclaration */);
|
|
Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
|
|
return getOuterTypeParameters(declaration);
|
|
}
|
|
function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
let result;
|
|
for (const node of symbol.declarations) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */ || node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */ || isJSConstructor(node) || isTypeAlias(node)) {
|
|
const declaration = node;
|
|
result = appendTypeParameters(result, getEffectiveTypeParameterDeclarations(declaration));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeParametersOfClassOrInterface(symbol) {
|
|
return concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
|
|
}
|
|
function isMixinConstructorType(type) {
|
|
const signatures = getSignaturesOfType(type, 1 /* Construct */);
|
|
if (signatures.length === 1) {
|
|
const s = signatures[0];
|
|
if (!s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s)) {
|
|
const paramType = getTypeOfParameter(s.parameters[0]);
|
|
return isTypeAny(paramType) || getElementTypeOfArrayType(paramType) === anyType;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isConstructorType(type) {
|
|
if (getSignaturesOfType(type, 1 /* Construct */).length > 0) {
|
|
return true;
|
|
}
|
|
if (type.flags & 8650752 /* TypeVariable */) {
|
|
const constraint = getBaseConstraintOfType(type);
|
|
return !!constraint && isMixinConstructorType(constraint);
|
|
}
|
|
return false;
|
|
}
|
|
function getBaseTypeNodeOfClass(type) {
|
|
const decl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
return decl && getEffectiveBaseTypeNode(decl);
|
|
}
|
|
function getConstructorsForTypeArguments(type, typeArgumentNodes, location) {
|
|
const typeArgCount = length(typeArgumentNodes);
|
|
const isJavascript = isInJSFile(location);
|
|
return filter(
|
|
getSignaturesOfType(type, 1 /* Construct */),
|
|
(sig) => (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= length(sig.typeParameters)
|
|
);
|
|
}
|
|
function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location) {
|
|
const signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
|
|
const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
|
|
return sameMap(signatures, (sig) => some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, isInJSFile(location)) : sig);
|
|
}
|
|
function getBaseConstructorTypeOfClass(type) {
|
|
if (!type.resolvedBaseConstructorType) {
|
|
const decl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
const extended = decl && getEffectiveBaseTypeNode(decl);
|
|
const baseTypeNode = getBaseTypeNodeOfClass(type);
|
|
if (!baseTypeNode) {
|
|
return type.resolvedBaseConstructorType = undefinedType;
|
|
}
|
|
if (!pushTypeResolution(type, 1 /* ResolvedBaseConstructorType */)) {
|
|
return errorType;
|
|
}
|
|
const baseConstructorType = checkExpression(baseTypeNode.expression);
|
|
if (extended && baseTypeNode !== extended) {
|
|
Debug.assert(!extended.typeArguments);
|
|
checkExpression(extended.expression);
|
|
}
|
|
if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */)) {
|
|
resolveStructuredTypeMembers(baseConstructorType);
|
|
}
|
|
if (!popTypeResolution()) {
|
|
error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
|
|
return type.resolvedBaseConstructorType = errorType;
|
|
}
|
|
if (!(baseConstructorType.flags & 1 /* Any */) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
|
|
const err = error(baseTypeNode.expression, Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
|
|
if (baseConstructorType.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getConstraintFromTypeParameter(baseConstructorType);
|
|
let ctorReturn = unknownType;
|
|
if (constraint) {
|
|
const ctorSig = getSignaturesOfType(constraint, 1 /* Construct */);
|
|
if (ctorSig[0]) {
|
|
ctorReturn = getReturnTypeOfSignature(ctorSig[0]);
|
|
}
|
|
}
|
|
if (baseConstructorType.symbol.declarations) {
|
|
addRelatedInfo(err, createDiagnosticForNode(baseConstructorType.symbol.declarations[0], 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) {
|
|
let resolvedImplementsTypes = emptyArray;
|
|
if (type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
const implementsTypeNodes = getEffectiveImplementsTypeNodes(declaration);
|
|
if (!implementsTypeNodes)
|
|
continue;
|
|
for (const node of implementsTypeNodes) {
|
|
const implementsType = getTypeFromTypeNode(node);
|
|
if (!isErrorType(implementsType)) {
|
|
if (resolvedImplementsTypes === emptyArray) {
|
|
resolvedImplementsTypes = [implementsType];
|
|
} else {
|
|
resolvedImplementsTypes.push(implementsType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return resolvedImplementsTypes;
|
|
}
|
|
function reportCircularBaseType(node, type) {
|
|
error(node, Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, void 0, 2 /* WriteArrayAsGenericType */));
|
|
}
|
|
function getBaseTypes(type) {
|
|
if (!type.baseTypesResolved) {
|
|
if (pushTypeResolution(type, 7 /* ResolvedBaseTypes */)) {
|
|
if (type.objectFlags & 8 /* Tuple */) {
|
|
type.resolvedBaseTypes = [getTupleBaseType(type)];
|
|
} else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
|
|
if (type.symbol.flags & 32 /* Class */) {
|
|
resolveBaseTypesOfClass(type);
|
|
}
|
|
if (type.symbol.flags & 64 /* Interface */) {
|
|
resolveBaseTypesOfInterface(type);
|
|
}
|
|
} else {
|
|
Debug.fail("type must be class or interface");
|
|
}
|
|
if (!popTypeResolution() && type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
if (declaration.kind === 260 /* ClassDeclaration */ || declaration.kind === 261 /* InterfaceDeclaration */) {
|
|
reportCircularBaseType(declaration, type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
type.baseTypesResolved = true;
|
|
}
|
|
return type.resolvedBaseTypes;
|
|
}
|
|
function getTupleBaseType(type) {
|
|
const elementTypes = sameMap(type.typeParameters, (t, i) => type.elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t);
|
|
return createArrayType(getUnionType(elementTypes || emptyArray), type.readonly);
|
|
}
|
|
function resolveBaseTypesOfClass(type) {
|
|
type.resolvedBaseTypes = resolvingEmptyArray;
|
|
const baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type));
|
|
if (!(baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 1 /* Any */))) {
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
const baseTypeNode = getBaseTypeNodeOfClass(type);
|
|
let baseType;
|
|
const originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : void 0;
|
|
if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 /* Class */ && areAllOuterTypeParametersApplied(originalBaseType)) {
|
|
baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol);
|
|
} else if (baseConstructorType.flags & 1 /* Any */) {
|
|
baseType = baseConstructorType;
|
|
} else {
|
|
const constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode);
|
|
if (!constructors.length) {
|
|
error(baseTypeNode.expression, Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
baseType = getReturnTypeOfSignature(constructors[0]);
|
|
}
|
|
if (isErrorType(baseType)) {
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
const reducedBaseType = getReducedType(baseType);
|
|
if (!isValidBaseType(reducedBaseType)) {
|
|
const elaboration = elaborateNeverIntersection(void 0, baseType);
|
|
const diagnostic = chainDiagnosticMessages(elaboration, Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(reducedBaseType));
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(baseTypeNode.expression, diagnostic));
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
if (type === reducedBaseType || hasBaseType(reducedBaseType, type)) {
|
|
error(
|
|
type.symbol.valueDeclaration,
|
|
Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
|
|
typeToString(type, void 0, 2 /* WriteArrayAsGenericType */)
|
|
);
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
if (type.resolvedBaseTypes === resolvingEmptyArray) {
|
|
type.members = void 0;
|
|
}
|
|
return type.resolvedBaseTypes = [reducedBaseType];
|
|
}
|
|
function areAllOuterTypeParametersApplied(type) {
|
|
const outerTypeParameters = type.outerTypeParameters;
|
|
if (outerTypeParameters) {
|
|
const last2 = outerTypeParameters.length - 1;
|
|
const typeArguments = getTypeArguments(type);
|
|
return outerTypeParameters[last2].symbol !== typeArguments[last2].symbol;
|
|
}
|
|
return true;
|
|
}
|
|
function isValidBaseType(type) {
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getBaseConstraintOfType(type);
|
|
if (constraint) {
|
|
return isValidBaseType(constraint);
|
|
}
|
|
}
|
|
return !!(type.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 1 /* Any */) && !isGenericMappedType(type) || type.flags & 2097152 /* Intersection */ && every(type.types, isValidBaseType));
|
|
}
|
|
function resolveBaseTypesOfInterface(type) {
|
|
type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
|
|
if (type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
if (declaration.kind === 261 /* InterfaceDeclaration */ && getInterfaceBaseTypeNodes(declaration)) {
|
|
for (const node of getInterfaceBaseTypeNodes(declaration)) {
|
|
const baseType = getReducedType(getTypeFromTypeNode(node));
|
|
if (!isErrorType(baseType)) {
|
|
if (isValidBaseType(baseType)) {
|
|
if (type !== baseType && !hasBaseType(baseType, type)) {
|
|
if (type.resolvedBaseTypes === emptyArray) {
|
|
type.resolvedBaseTypes = [baseType];
|
|
} else {
|
|
type.resolvedBaseTypes.push(baseType);
|
|
}
|
|
} else {
|
|
reportCircularBaseType(declaration, type);
|
|
}
|
|
} else {
|
|
error(node, Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isThislessInterface(symbol) {
|
|
if (!symbol.declarations) {
|
|
return true;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
if (declaration.kind === 261 /* InterfaceDeclaration */) {
|
|
if (declaration.flags & 128 /* ContainsThis */) {
|
|
return false;
|
|
}
|
|
const baseTypeNodes = getInterfaceBaseTypeNodes(declaration);
|
|
if (baseTypeNodes) {
|
|
for (const node of baseTypeNodes) {
|
|
if (isEntityNameExpression(node.expression)) {
|
|
const baseSymbol = resolveEntityName(node.expression, 788968 /* Type */, true);
|
|
if (!baseSymbol || !(baseSymbol.flags & 64 /* Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getDeclaredTypeOfClassOrInterface(symbol) {
|
|
let links = getSymbolLinks(symbol);
|
|
const originalLinks = links;
|
|
if (!links.declaredType) {
|
|
const kind = symbol.flags & 32 /* Class */ ? 1 /* Class */ : 2 /* Interface */;
|
|
const merged = mergeJSSymbols(symbol, symbol.valueDeclaration && getAssignedClassSymbol(symbol.valueDeclaration));
|
|
if (merged) {
|
|
symbol = links = merged;
|
|
}
|
|
const type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol);
|
|
const outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
|
|
const localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
if (outerTypeParameters || localTypeParameters || kind === 1 /* Class */ || !isThislessInterface(symbol)) {
|
|
type.objectFlags |= 4 /* Reference */;
|
|
type.typeParameters = concatenate(outerTypeParameters, localTypeParameters);
|
|
type.outerTypeParameters = outerTypeParameters;
|
|
type.localTypeParameters = localTypeParameters;
|
|
type.instantiations = /* @__PURE__ */ new 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 _a2;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
if (!pushTypeResolution(symbol, 2 /* DeclaredType */)) {
|
|
return errorType;
|
|
}
|
|
const declaration = Debug.checkDefined((_a2 = symbol.declarations) == null ? void 0 : _a2.find(isTypeAlias), "Type alias symbol with no valid declaration found");
|
|
const typeNode = isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type;
|
|
let type = typeNode ? getTypeFromTypeNode(typeNode) : errorType;
|
|
if (popTypeResolution()) {
|
|
const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
if (typeParameters) {
|
|
links.typeParameters = typeParameters;
|
|
links.instantiations = /* @__PURE__ */ new Map();
|
|
links.instantiations.set(getTypeListId(typeParameters), type);
|
|
}
|
|
} else {
|
|
type = errorType;
|
|
if (declaration.kind === 342 /* JSDocEnumTag */) {
|
|
error(declaration.typeExpression.type, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
|
|
} else {
|
|
error(isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
|
|
}
|
|
}
|
|
links.declaredType = type;
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getBaseTypeOfEnumLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
|
|
}
|
|
function getDeclaredTypeOfEnum(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
const memberTypeList = [];
|
|
if (symbol.declarations) {
|
|
for (const declaration of symbol.declarations) {
|
|
if (declaration.kind === 263 /* EnumDeclaration */) {
|
|
for (const member of declaration.members) {
|
|
if (hasBindableName(member)) {
|
|
const memberSymbol = getSymbolOfNode(member);
|
|
const value = getEnumMemberValue(member);
|
|
const memberType = value !== void 0 ? getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) : createTypeWithSymbol(32 /* Enum */, memberSymbol);
|
|
getSymbolLinks(memberSymbol).declaredType = memberType;
|
|
memberTypeList.push(getRegularTypeOfLiteralType(memberType));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const enumType = memberTypeList.length ? getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0) : createTypeWithSymbol(32 /* Enum */, symbol);
|
|
if (enumType.flags & 1048576 /* Union */) {
|
|
enumType.flags |= 1024 /* EnumLiteral */;
|
|
enumType.symbol = symbol;
|
|
}
|
|
links.declaredType = enumType;
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getDeclaredTypeOfEnumMember(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
const enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
|
|
if (!links.declaredType) {
|
|
links.declaredType = enumType;
|
|
}
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getDeclaredTypeOfTypeParameter(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.declaredType || (links.declaredType = createTypeParameter(symbol));
|
|
}
|
|
function getDeclaredTypeOfAlias(symbol) {
|
|
const 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 /* Class */ | 64 /* Interface */)) {
|
|
return getDeclaredTypeOfClassOrInterface(symbol);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
return getDeclaredTypeOfTypeAlias(symbol);
|
|
}
|
|
if (symbol.flags & 262144 /* TypeParameter */) {
|
|
return getDeclaredTypeOfTypeParameter(symbol);
|
|
}
|
|
if (symbol.flags & 384 /* Enum */) {
|
|
return getDeclaredTypeOfEnum(symbol);
|
|
}
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return getDeclaredTypeOfEnumMember(symbol);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
return getDeclaredTypeOfAlias(symbol);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isThislessType(node) {
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 198 /* LiteralType */:
|
|
return true;
|
|
case 185 /* ArrayType */:
|
|
return isThislessType(node.elementType);
|
|
case 180 /* TypeReference */:
|
|
return !node.typeArguments || node.typeArguments.every(isThislessType);
|
|
}
|
|
return false;
|
|
}
|
|
function isThislessTypeParameter(node) {
|
|
const constraint = getEffectiveConstraintOfTypeParameter(node);
|
|
return !constraint || isThislessType(constraint);
|
|
}
|
|
function isThislessVariableLikeDeclaration(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
return typeNode ? isThislessType(typeNode) : !hasInitializer(node);
|
|
}
|
|
function isThislessFunctionLikeDeclaration(node) {
|
|
const returnType = getEffectiveReturnTypeNode(node);
|
|
const typeParameters = getEffectiveTypeParameterDeclarations(node);
|
|
return (node.kind === 173 /* Constructor */ || !!returnType && isThislessType(returnType)) && node.parameters.every(isThislessVariableLikeDeclaration) && typeParameters.every(isThislessTypeParameter);
|
|
}
|
|
function isThisless(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length === 1) {
|
|
const declaration = symbol.declarations[0];
|
|
if (declaration) {
|
|
switch (declaration.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return isThislessVariableLikeDeclaration(declaration);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return isThislessFunctionLikeDeclaration(declaration);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
|
|
const result = createSymbolTable();
|
|
for (const symbol of symbols) {
|
|
result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper));
|
|
}
|
|
return result;
|
|
}
|
|
function addInheritedMembers(symbols, baseSymbols) {
|
|
for (const s of baseSymbols) {
|
|
if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) {
|
|
symbols.set(s.escapedName, s);
|
|
}
|
|
}
|
|
}
|
|
function isStaticPrivateIdentifierProperty(s) {
|
|
return !!s.valueDeclaration && isPrivateIdentifierClassElementDeclaration(s.valueDeclaration) && isStatic(s.valueDeclaration);
|
|
}
|
|
function resolveDeclaredMembers(type) {
|
|
if (!type.declaredProperties) {
|
|
const symbol = type.symbol;
|
|
const members = getMembersOfSymbol(symbol);
|
|
type.declaredProperties = getNamedMembers(members);
|
|
type.declaredCallSignatures = emptyArray;
|
|
type.declaredConstructSignatures = emptyArray;
|
|
type.declaredIndexInfos = emptyArray;
|
|
type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call" /* Call */));
|
|
type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new" /* New */));
|
|
type.declaredIndexInfos = getIndexInfosOfSymbol(symbol);
|
|
}
|
|
return type;
|
|
}
|
|
function isTypeUsableAsPropertyName(type) {
|
|
return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
|
|
}
|
|
function isLateBindableName(node) {
|
|
if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
|
|
return false;
|
|
}
|
|
const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
|
|
return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
|
|
}
|
|
function isLateBoundName(name) {
|
|
return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) === 64 /* at */;
|
|
}
|
|
function hasLateBindableName(node) {
|
|
const name = getNameOfDeclaration(node);
|
|
return !!name && isLateBindableName(name);
|
|
}
|
|
function hasBindableName(node) {
|
|
return !hasDynamicName(node) || hasLateBindableName(node);
|
|
}
|
|
function isNonBindableDynamicName(node) {
|
|
return isDynamicName(node) && !isLateBindableName(node);
|
|
}
|
|
function getPropertyNameFromType(type) {
|
|
if (type.flags & 8192 /* UniqueESSymbol */) {
|
|
return type.escapedName;
|
|
}
|
|
if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
return escapeLeadingUnderscores("" + type.value);
|
|
}
|
|
return Debug.fail();
|
|
}
|
|
function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
|
|
Debug.assert(!!(getCheckFlags(symbol) & 4096 /* 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 /* Value */) {
|
|
if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) {
|
|
symbol.valueDeclaration = member;
|
|
}
|
|
}
|
|
}
|
|
function lateBindMember(parent, earlySymbols, lateSymbols, decl) {
|
|
Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
|
|
const links = getNodeLinks(decl);
|
|
if (!links.resolvedSymbol) {
|
|
links.resolvedSymbol = decl.symbol;
|
|
const declName = isBinaryExpression(decl) ? decl.left : decl.name;
|
|
const type = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
|
|
if (isTypeUsableAsPropertyName(type)) {
|
|
const memberName = getPropertyNameFromType(type);
|
|
const symbolFlags = decl.symbol.flags;
|
|
let lateSymbol = lateSymbols.get(memberName);
|
|
if (!lateSymbol)
|
|
lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */));
|
|
const earlySymbol = earlySymbols && earlySymbols.get(memberName);
|
|
if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) {
|
|
const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
|
|
const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
|
|
forEach(declarations, (declaration) => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
|
|
error(declName || decl, Diagnostics.Duplicate_property_0, name);
|
|
lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */);
|
|
}
|
|
lateSymbol.nameType = type;
|
|
addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags);
|
|
if (lateSymbol.parent) {
|
|
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) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links[resolutionKind]) {
|
|
const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
|
|
const earlySymbols = !isStatic2 ? symbol.members : symbol.flags & 1536 /* Module */ ? getExportsOfModuleWorker(symbol) : symbol.exports;
|
|
links[resolutionKind] = earlySymbols || emptySymbols;
|
|
const lateSymbols = createSymbolTable();
|
|
for (const decl of symbol.declarations || emptyArray) {
|
|
const members = getMembersOfDeclaration(decl);
|
|
if (members) {
|
|
for (const member of members) {
|
|
if (isStatic2 === hasStaticModifier(member)) {
|
|
if (hasLateBindableName(member)) {
|
|
lateBindMember(symbol, earlySymbols, lateSymbols, member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const assignments = symbol.assignmentDeclarationMembers;
|
|
if (assignments) {
|
|
const decls = arrayFrom(assignments.values());
|
|
for (const member of decls) {
|
|
const assignmentKind = getAssignmentDeclarationKind(member);
|
|
const isInstanceMember = assignmentKind === 3 /* PrototypeProperty */ || isBinaryExpression(member) && isPossiblyAliasedThisProperty(member, assignmentKind) || assignmentKind === 9 /* ObjectDefinePrototypeProperty */ || assignmentKind === 6 /* Prototype */;
|
|
if (isStatic2 === !isInstanceMember) {
|
|
if (hasLateBindableName(member)) {
|
|
lateBindMember(symbol, earlySymbols, lateSymbols, member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
|
|
}
|
|
return links[resolutionKind];
|
|
}
|
|
function getMembersOfSymbol(symbol) {
|
|
return symbol.flags & 6256 /* LateBindingContainer */ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers" /* resolvedMembers */) : symbol.members || emptySymbols;
|
|
}
|
|
function getLateBoundSymbol(symbol) {
|
|
if (symbol.flags & 106500 /* ClassMember */ && symbol.escapedName === "__computed" /* Computed */) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.lateSymbol && some(symbol.declarations, hasLateBindableName)) {
|
|
const parent = getMergedSymbol(symbol.parent);
|
|
if (some(symbol.declarations, hasStaticModifier)) {
|
|
getExportsOfSymbol(parent);
|
|
} else {
|
|
getMembersOfSymbol(parent);
|
|
}
|
|
}
|
|
return links.lateSymbol || (links.lateSymbol = symbol);
|
|
}
|
|
return symbol;
|
|
}
|
|
function getTypeWithThisArgument(type, thisArgument, needApparentType) {
|
|
if (getObjectFlags(type) & 4 /* Reference */) {
|
|
const target = type.target;
|
|
const typeArguments = getTypeArguments(type);
|
|
if (length(target.typeParameters) === length(typeArguments)) {
|
|
const ref = createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
|
|
return needApparentType ? getApparentType(ref) : ref;
|
|
}
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
const types = sameMap(type.types, (t) => getTypeWithThisArgument(t, thisArgument, needApparentType));
|
|
return types !== type.types ? getIntersectionType(types) : type;
|
|
}
|
|
return needApparentType ? getApparentType(type) : type;
|
|
}
|
|
function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
|
|
let mapper;
|
|
let members;
|
|
let callSignatures;
|
|
let constructSignatures;
|
|
let indexInfos;
|
|
if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
|
|
members = source.symbol ? getMembersOfSymbol(source.symbol) : createSymbolTable(source.declaredProperties);
|
|
callSignatures = source.declaredCallSignatures;
|
|
constructSignatures = source.declaredConstructSignatures;
|
|
indexInfos = source.declaredIndexInfos;
|
|
} else {
|
|
mapper = createTypeMapper(typeParameters, typeArguments);
|
|
members = createInstantiatedSymbolTable(source.declaredProperties, mapper, typeParameters.length === 1);
|
|
callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper);
|
|
constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper);
|
|
indexInfos = instantiateIndexInfos(source.declaredIndexInfos, mapper);
|
|
}
|
|
const baseTypes = getBaseTypes(source);
|
|
if (baseTypes.length) {
|
|
if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
|
|
members = createSymbolTable(source.declaredProperties);
|
|
}
|
|
setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
|
|
const thisArgument = lastOrUndefined(typeArguments);
|
|
for (const baseType of baseTypes) {
|
|
const instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
|
|
addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType));
|
|
callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */));
|
|
constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* Construct */));
|
|
const inheritedIndexInfos = instantiatedBaseType !== anyType ? getIndexInfosOfType(instantiatedBaseType) : [createIndexInfo(stringType, anyType, false)];
|
|
indexInfos = concatenate(indexInfos, filter(inheritedIndexInfos, (info) => !findIndexInfo(indexInfos, info.keyType)));
|
|
}
|
|
}
|
|
setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
|
|
}
|
|
function resolveClassOrInterfaceMembers(type) {
|
|
resolveObjectTypeMembers(type, resolveDeclaredMembers(type), emptyArray, emptyArray);
|
|
}
|
|
function resolveTypeReferenceMembers(type) {
|
|
const source = resolveDeclaredMembers(type.target);
|
|
const typeParameters = concatenate(source.typeParameters, [source.thisType]);
|
|
const typeArguments = getTypeArguments(type);
|
|
const paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : concatenate(typeArguments, [type]);
|
|
resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments);
|
|
}
|
|
function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) {
|
|
const sig = new Signature5(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 = void 0;
|
|
sig.target = void 0;
|
|
sig.mapper = void 0;
|
|
sig.compositeSignatures = void 0;
|
|
sig.compositeKind = void 0;
|
|
return sig;
|
|
}
|
|
function cloneSignature(sig) {
|
|
const result = createSignature(
|
|
sig.declaration,
|
|
sig.typeParameters,
|
|
sig.thisParameter,
|
|
sig.parameters,
|
|
void 0,
|
|
void 0,
|
|
sig.minArgumentCount,
|
|
sig.flags & 39 /* PropagatingFlags */
|
|
);
|
|
result.target = sig.target;
|
|
result.mapper = sig.mapper;
|
|
result.compositeSignatures = sig.compositeSignatures;
|
|
result.compositeKind = sig.compositeKind;
|
|
return result;
|
|
}
|
|
function createUnionSignature(signature, unionSignatures) {
|
|
const result = cloneSignature(signature);
|
|
result.compositeSignatures = unionSignatures;
|
|
result.compositeKind = 1048576 /* Union */;
|
|
result.target = void 0;
|
|
result.mapper = void 0;
|
|
return result;
|
|
}
|
|
function getOptionalCallSignature(signature, callChainFlags) {
|
|
if ((signature.flags & 24 /* CallChainFlags */) === callChainFlags) {
|
|
return signature;
|
|
}
|
|
if (!signature.optionalCallSignatureCache) {
|
|
signature.optionalCallSignatureCache = {};
|
|
}
|
|
const key = callChainFlags === 8 /* IsInnerCallChain */ ? "inner" : "outer";
|
|
return signature.optionalCallSignatureCache[key] || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags));
|
|
}
|
|
function createOptionalCallSignature(signature, callChainFlags) {
|
|
Debug.assert(
|
|
callChainFlags === 8 /* IsInnerCallChain */ || callChainFlags === 16 /* IsOuterCallChain */,
|
|
"An optional call signature can either be for an inner call chain or an outer call chain, but not both."
|
|
);
|
|
const result = cloneSignature(signature);
|
|
result.flags |= callChainFlags;
|
|
return result;
|
|
}
|
|
function getExpandedParameters(sig, skipUnionExpanding) {
|
|
if (signatureHasRestParameter(sig)) {
|
|
const restIndex = sig.parameters.length - 1;
|
|
const restType = getTypeOfSymbol(sig.parameters[restIndex]);
|
|
if (isTupleType(restType)) {
|
|
return [expandSignatureParametersWithTupleMembers(restType, restIndex)];
|
|
} else if (!skipUnionExpanding && restType.flags & 1048576 /* Union */ && every(restType.types, isTupleType)) {
|
|
return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex));
|
|
}
|
|
}
|
|
return [sig.parameters];
|
|
function expandSignatureParametersWithTupleMembers(restType, restIndex) {
|
|
const elementTypes = getTypeArguments(restType);
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const restParams = map(elementTypes, (t, i) => {
|
|
const tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]);
|
|
const name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i, restType);
|
|
const flags = restType.target.elementFlags[i];
|
|
const checkFlags = flags & 12 /* Variable */ ? 32768 /* RestParameter */ : flags & 2 /* Optional */ ? 16384 /* OptionalParameter */ : 0;
|
|
const symbol = createSymbol(1 /* FunctionScopedVariable */, name, checkFlags);
|
|
symbol.type = flags & 4 /* Rest */ ? createArrayType(t) : t;
|
|
return symbol;
|
|
});
|
|
return concatenate(sig.parameters.slice(0, restIndex), restParams);
|
|
}
|
|
}
|
|
function getDefaultConstructSignatures(classType) {
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classType);
|
|
const baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
|
|
const declaration = getClassLikeDeclarationOfSymbol(classType.symbol);
|
|
const isAbstract = !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
|
|
if (baseSignatures.length === 0) {
|
|
return [createSignature(void 0, classType.localTypeParameters, void 0, emptyArray, classType, void 0, 0, isAbstract ? 4 /* Abstract */ : 0 /* None */)];
|
|
}
|
|
const baseTypeNode = getBaseTypeNodeOfClass(classType);
|
|
const isJavaScript = isInJSFile(baseTypeNode);
|
|
const typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode);
|
|
const typeArgCount = length(typeArguments);
|
|
const result = [];
|
|
for (const baseSig of baseSignatures) {
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
|
|
const typeParamCount = length(baseSig.typeParameters);
|
|
if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) {
|
|
const 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 /* Abstract */ : sig.flags & ~4 /* Abstract */;
|
|
result.push(sig);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
|
|
for (const s of signatureList) {
|
|
if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) {
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
function findMatchingSignatures(signatureLists, signature, listIndex) {
|
|
if (signature.typeParameters) {
|
|
if (listIndex > 0) {
|
|
return void 0;
|
|
}
|
|
for (let i = 1; i < signatureLists.length; i++) {
|
|
if (!findMatchingSignature(signatureLists[i], signature, false, false, false)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return [signature];
|
|
}
|
|
let result;
|
|
for (let i = 0; i < signatureLists.length; i++) {
|
|
const match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, true, false, true);
|
|
if (!match) {
|
|
return void 0;
|
|
}
|
|
result = appendIfUnique(result, match);
|
|
}
|
|
return result;
|
|
}
|
|
function getUnionSignatures(signatureLists) {
|
|
let result;
|
|
let indexWithLengthOverOne;
|
|
for (let i = 0; i < signatureLists.length; i++) {
|
|
if (signatureLists[i].length === 0)
|
|
return emptyArray;
|
|
if (signatureLists[i].length > 1) {
|
|
indexWithLengthOverOne = indexWithLengthOverOne === void 0 ? i : -1;
|
|
}
|
|
for (const signature of signatureLists[i]) {
|
|
if (!result || !findMatchingSignature(result, signature, false, false, true)) {
|
|
const unionSignatures = findMatchingSignatures(signatureLists, signature, i);
|
|
if (unionSignatures) {
|
|
let s = signature;
|
|
if (unionSignatures.length > 1) {
|
|
let thisParameter = signature.thisParameter;
|
|
const firstThisParameterOfUnionSignatures = forEach(unionSignatures, (sig) => sig.thisParameter);
|
|
if (firstThisParameterOfUnionSignatures) {
|
|
const thisType = getIntersectionType(mapDefined(unionSignatures, (sig) => sig.thisParameter && getTypeOfSymbol(sig.thisParameter)));
|
|
thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType);
|
|
}
|
|
s = createUnionSignature(signature, unionSignatures);
|
|
s.thisParameter = thisParameter;
|
|
}
|
|
(result || (result = [])).push(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!length(result) && indexWithLengthOverOne !== -1) {
|
|
const masterList = signatureLists[indexWithLengthOverOne !== void 0 ? indexWithLengthOverOne : 0];
|
|
let results = masterList.slice();
|
|
for (const signatures of signatureLists) {
|
|
if (signatures !== masterList) {
|
|
const signature = signatures[0];
|
|
Debug.assert(!!signature, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
|
|
results = !!signature.typeParameters && some(results, (s) => !!s.typeParameters && !compareTypeParametersIdentical(signature.typeParameters, s.typeParameters)) ? void 0 : map(results, (sig) => combineSignaturesOfUnionMembers(sig, signature));
|
|
if (!results) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
result = results;
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function compareTypeParametersIdentical(sourceParams, targetParams) {
|
|
if (length(sourceParams) !== length(targetParams)) {
|
|
return false;
|
|
}
|
|
if (!sourceParams || !targetParams) {
|
|
return true;
|
|
}
|
|
const mapper = createTypeMapper(targetParams, sourceParams);
|
|
for (let i = 0; i < sourceParams.length; i++) {
|
|
const source = sourceParams[i];
|
|
const target = targetParams[i];
|
|
if (source === target)
|
|
continue;
|
|
if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, instantiateType(getConstraintFromTypeParameter(target) || unknownType, mapper)))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function combineUnionThisParam(left, right, mapper) {
|
|
if (!left || !right) {
|
|
return left || right;
|
|
}
|
|
const thisType = getIntersectionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]);
|
|
return createSymbolWithType(left, thisType);
|
|
}
|
|
function combineUnionParameters(left, right, mapper) {
|
|
const leftCount = getParameterCount(left);
|
|
const rightCount = getParameterCount(right);
|
|
const longest = leftCount >= rightCount ? left : right;
|
|
const shorter = longest === left ? right : left;
|
|
const longestCount = longest === left ? leftCount : rightCount;
|
|
const eitherHasEffectiveRest = hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right);
|
|
const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
|
|
const params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
|
|
for (let i = 0; i < longestCount; i++) {
|
|
let longestParamType = tryGetTypeAtPosition(longest, i);
|
|
if (longest === right) {
|
|
longestParamType = instantiateType(longestParamType, mapper);
|
|
}
|
|
let shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
|
|
if (shorter === right) {
|
|
shorterParamType = instantiateType(shorterParamType, mapper);
|
|
}
|
|
const unionParamType = getIntersectionType([longestParamType, shorterParamType]);
|
|
const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === longestCount - 1;
|
|
const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
|
|
const leftName = i >= leftCount ? void 0 : getParameterNameAtPosition(left, i);
|
|
const rightName = i >= rightCount ? void 0 : getParameterNameAtPosition(right, i);
|
|
const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
|
|
const paramSymbol = createSymbol(
|
|
1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
|
|
paramName || `arg${i}`
|
|
);
|
|
paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
|
|
params[i] = paramSymbol;
|
|
}
|
|
if (needsExtraRestElement) {
|
|
const restParamSymbol = createSymbol(1 /* 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) {
|
|
const typeParams = left.typeParameters || right.typeParameters;
|
|
let paramMapper;
|
|
if (left.typeParameters && right.typeParameters) {
|
|
paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
|
|
}
|
|
const declaration = left.declaration;
|
|
const params = combineUnionParameters(left, right, paramMapper);
|
|
const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper);
|
|
const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
|
|
const result = createSignature(
|
|
declaration,
|
|
typeParams,
|
|
thisParam,
|
|
params,
|
|
void 0,
|
|
void 0,
|
|
minArgCount,
|
|
(left.flags | right.flags) & 39 /* PropagatingFlags */
|
|
);
|
|
result.compositeKind = 1048576 /* Union */;
|
|
result.compositeSignatures = concatenate(left.compositeKind !== 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
|
|
if (paramMapper) {
|
|
result.mapper = left.compositeKind !== 2097152 /* Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper;
|
|
}
|
|
return result;
|
|
}
|
|
function getUnionIndexInfos(types) {
|
|
const sourceInfos = getIndexInfosOfType(types[0]);
|
|
if (sourceInfos) {
|
|
const result = [];
|
|
for (const info of sourceInfos) {
|
|
const indexType = info.keyType;
|
|
if (every(types, (t) => !!getIndexInfoOfType(t, indexType))) {
|
|
result.push(createIndexInfo(
|
|
indexType,
|
|
getUnionType(map(types, (t) => getIndexTypeOfType(t, indexType))),
|
|
some(types, (t) => getIndexInfoOfType(t, indexType).isReadonly)
|
|
));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function resolveUnionTypeMembers(type) {
|
|
const callSignatures = getUnionSignatures(map(type.types, (t) => t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0 /* Call */)));
|
|
const constructSignatures = getUnionSignatures(map(type.types, (t) => getSignaturesOfType(t, 1 /* Construct */)));
|
|
const 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) {
|
|
const constructorTypeCount = countWhere(types, (t) => getSignaturesOfType(t, 1 /* Construct */).length > 0);
|
|
const mixinFlags = map(types, isMixinConstructorType);
|
|
if (constructorTypeCount > 0 && constructorTypeCount === countWhere(mixinFlags, (b) => b)) {
|
|
const firstMixinIndex = mixinFlags.indexOf(true);
|
|
mixinFlags[firstMixinIndex] = false;
|
|
}
|
|
return mixinFlags;
|
|
}
|
|
function includeMixinType(type, types, mixinFlags, index) {
|
|
const mixedTypes = [];
|
|
for (let i = 0; i < types.length; i++) {
|
|
if (i === index) {
|
|
mixedTypes.push(type);
|
|
} else if (mixinFlags[i]) {
|
|
mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1 /* Construct */)[0]));
|
|
}
|
|
}
|
|
return getIntersectionType(mixedTypes);
|
|
}
|
|
function resolveIntersectionTypeMembers(type) {
|
|
let callSignatures;
|
|
let constructSignatures;
|
|
let indexInfos;
|
|
const types = type.types;
|
|
const mixinFlags = findMixins(types);
|
|
const mixinCount = countWhere(mixinFlags, (b) => b);
|
|
for (let i = 0; i < types.length; i++) {
|
|
const t = type.types[i];
|
|
if (!mixinFlags[i]) {
|
|
let signatures = getSignaturesOfType(t, 1 /* Construct */);
|
|
if (signatures.length && mixinCount > 0) {
|
|
signatures = map(signatures, (s) => {
|
|
const clone2 = cloneSignature(s);
|
|
clone2.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i);
|
|
return clone2;
|
|
});
|
|
}
|
|
constructSignatures = appendSignatures(constructSignatures, signatures);
|
|
}
|
|
callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0 /* Call */));
|
|
indexInfos = reduceLeft(getIndexInfosOfType(t), (infos, newInfo) => appendIndexInfo(infos, newInfo, false), indexInfos);
|
|
}
|
|
setStructuredTypeMembers(type, emptySymbols, callSignatures || emptyArray, constructSignatures || emptyArray, indexInfos || emptyArray);
|
|
}
|
|
function appendSignatures(signatures, newSignatures) {
|
|
for (const sig of newSignatures) {
|
|
if (!signatures || every(signatures, (s) => !compareSignaturesIdentical(s, sig, false, false, false, compareTypesIdentical))) {
|
|
signatures = append(signatures, sig);
|
|
}
|
|
}
|
|
return signatures;
|
|
}
|
|
function appendIndexInfo(indexInfos, newInfo, union) {
|
|
if (indexInfos) {
|
|
for (let i = 0; i < indexInfos.length; i++) {
|
|
const 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 append(indexInfos, newInfo);
|
|
}
|
|
function resolveAnonymousTypeMembers(type) {
|
|
if (type.target) {
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const members2 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, false);
|
|
const callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* Call */), type.mapper);
|
|
const constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper);
|
|
const indexInfos2 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
|
|
setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
|
|
return;
|
|
}
|
|
const symbol = getMergedSymbol(type.symbol);
|
|
if (symbol.flags & 2048 /* TypeLiteral */) {
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const members2 = getMembersOfSymbol(symbol);
|
|
const callSignatures = getSignaturesOfSymbol(members2.get("__call" /* Call */));
|
|
const constructSignatures = getSignaturesOfSymbol(members2.get("__new" /* New */));
|
|
const indexInfos2 = getIndexInfosOfSymbol(symbol);
|
|
setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
|
|
return;
|
|
}
|
|
let members = emptySymbols;
|
|
let indexInfos;
|
|
if (symbol.exports) {
|
|
members = getExportsOfSymbol(symbol);
|
|
if (symbol === globalThisSymbol) {
|
|
const varsOnly = /* @__PURE__ */ new Map();
|
|
members.forEach((p) => {
|
|
var _a2;
|
|
if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a2 = p.declarations) == null ? void 0 : _a2.length) && every(p.declarations, isAmbientModule))) {
|
|
varsOnly.set(p.escapedName, p);
|
|
}
|
|
});
|
|
members = varsOnly;
|
|
}
|
|
}
|
|
let baseConstructorIndexInfo;
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, emptyArray);
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classType);
|
|
if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
|
|
members = createSymbolTable(getNamedOrIndexSignatureMembers(members));
|
|
addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
|
|
} else if (baseConstructorType === anyType) {
|
|
baseConstructorIndexInfo = createIndexInfo(stringType, anyType, false);
|
|
}
|
|
}
|
|
const indexSymbol = getIndexSymbolFromSymbolTable(members);
|
|
if (indexSymbol) {
|
|
indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
|
|
} else {
|
|
if (baseConstructorIndexInfo) {
|
|
indexInfos = append(indexInfos, baseConstructorIndexInfo);
|
|
}
|
|
if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ || some(type.properties, (prop) => !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */)))) {
|
|
indexInfos = append(indexInfos, enumNumberIndexInfo);
|
|
}
|
|
}
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos || emptyArray);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
|
|
type.callSignatures = getSignaturesOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
let constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : emptyArray;
|
|
if (symbol.flags & 16 /* Function */) {
|
|
constructSignatures = addRange(constructSignatures.slice(), mapDefined(
|
|
type.callSignatures,
|
|
(sig) => isJSConstructor(sig.declaration) ? createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType, void 0, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) : void 0
|
|
));
|
|
}
|
|
if (!constructSignatures.length) {
|
|
constructSignatures = getDefaultConstructSignatures(classType);
|
|
}
|
|
type.constructSignatures = constructSignatures;
|
|
}
|
|
}
|
|
function replaceIndexedAccess(instantiable, type, replacement) {
|
|
return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
|
|
}
|
|
function resolveReverseMappedTypeMembers(type) {
|
|
const indexInfo = getIndexInfoOfType(type.source, stringType);
|
|
const modifiers = getMappedTypeModifiers(type.mappedType);
|
|
const readonlyMask = modifiers & 1 /* IncludeReadonly */ ? false : true;
|
|
const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
|
|
const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfType(type.source)) {
|
|
const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
|
|
const inferredProp = createSymbol(4 /* 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 /* IndexedAccess */ && type.constraintType.type.objectType.flags & 262144 /* TypeParameter */ && type.constraintType.type.indexType.flags & 262144 /* TypeParameter */) {
|
|
const newTypeParam = type.constraintType.type.objectType;
|
|
const 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, emptyArray, emptyArray, indexInfos);
|
|
}
|
|
function getLowerBoundOfKeyType(type) {
|
|
if (type.flags & 4194304 /* Index */) {
|
|
const t = getApparentType(type.type);
|
|
return isGenericTupleType(t) ? getKnownKeysOfTupleType(t) : getIndexType(t);
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
if (type.root.isDistributive) {
|
|
const checkType = type.checkType;
|
|
const constraint = getLowerBoundOfKeyType(checkType);
|
|
if (constraint !== checkType) {
|
|
return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return mapType(type, getLowerBoundOfKeyType, true);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
const types = type.types;
|
|
if (types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType) {
|
|
return type;
|
|
}
|
|
return getIntersectionType(sameMap(type.types, getLowerBoundOfKeyType));
|
|
}
|
|
return type;
|
|
}
|
|
function getIsLateCheckFlag(s) {
|
|
return getCheckFlags(s) & 4096 /* Late */;
|
|
}
|
|
function forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(type, include, stringsOnly, cb) {
|
|
for (const prop of getPropertiesOfType(type)) {
|
|
cb(getLiteralTypeFromProperty(prop, include));
|
|
}
|
|
if (type.flags & 1 /* Any */) {
|
|
cb(stringType);
|
|
} else {
|
|
for (const info of getIndexInfosOfType(type)) {
|
|
if (!stringsOnly || info.keyType.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
|
|
cb(info.keyType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function resolveMappedTypeMembers(type) {
|
|
const members = createSymbolTable();
|
|
let indexInfos;
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const typeParameter = getTypeParameterFromMappedType(type);
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
const nameType = getNameTypeFromMappedType(type.target || type);
|
|
const templateType = getTemplateTypeFromMappedType(type.target || type);
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
|
|
const templateModifiers = getMappedTypeModifiers(type);
|
|
const include = keyofStringsOnly ? 128 /* StringLiteral */ : 8576 /* StringOrNumberLiteralOrUnique */;
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
|
|
} else {
|
|
forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
|
|
}
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos || emptyArray);
|
|
function addMemberForKeyType(keyType) {
|
|
const propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
|
|
forEachType(propNameType, (t) => addMemberForKeyTypeWorker(keyType, t));
|
|
}
|
|
function addMemberForKeyTypeWorker(keyType, propNameType) {
|
|
if (isTypeUsableAsPropertyName(propNameType)) {
|
|
const propName = getPropertyNameFromType(propNameType);
|
|
const existingProp = members.get(propName);
|
|
if (existingProp) {
|
|
existingProp.nameType = getUnionType([existingProp.nameType, propNameType]);
|
|
existingProp.keyType = getUnionType([existingProp.keyType, keyType]);
|
|
} else {
|
|
const modifiersProp = isTypeUsableAsPropertyName(keyType) ? getPropertyOfType(modifiersType, getPropertyNameFromType(keyType)) : void 0;
|
|
const isOptional = !!(templateModifiers & 4 /* IncludeOptional */ || !(templateModifiers & 8 /* ExcludeOptional */) && modifiersProp && modifiersProp.flags & 16777216 /* Optional */);
|
|
const isReadonly = !!(templateModifiers & 1 /* IncludeReadonly */ || !(templateModifiers & 2 /* ExcludeReadonly */) && modifiersProp && isReadonlySymbol(modifiersProp));
|
|
const stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 /* Optional */;
|
|
const lateFlag = modifiersProp ? getIsLateCheckFlag(modifiersProp) : 0;
|
|
const prop = createSymbol(
|
|
4 /* Property */ | (isOptional ? 16777216 /* Optional */ : 0),
|
|
propName,
|
|
lateFlag | 262144 /* Mapped */ | (isReadonly ? 8 /* Readonly */ : 0) | (stripOptional ? 524288 /* StripOptional */ : 0)
|
|
);
|
|
prop.mappedType = type;
|
|
prop.nameType = propNameType;
|
|
prop.keyType = keyType;
|
|
if (modifiersProp) {
|
|
prop.syntheticOrigin = modifiersProp;
|
|
prop.declarations = nameType ? void 0 : modifiersProp.declarations;
|
|
}
|
|
members.set(propName, prop);
|
|
}
|
|
} else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* Any */ | 32 /* Enum */)) {
|
|
const indexKeyType = propNameType.flags & (1 /* Any */ | 4 /* String */) ? stringType : propNameType.flags & (8 /* Number */ | 32 /* Enum */) ? numberType : propNameType;
|
|
const propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType));
|
|
const indexInfo = createIndexInfo(indexKeyType, propType, !!(templateModifiers & 1 /* IncludeReadonly */));
|
|
indexInfos = appendIndexInfo(indexInfos, indexInfo, true);
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfMappedSymbol(symbol) {
|
|
if (!symbol.type) {
|
|
const mappedType = symbol.mappedType;
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
mappedType.containsError = true;
|
|
return errorType;
|
|
}
|
|
const templateType = getTemplateTypeFromMappedType(mappedType.target || mappedType);
|
|
const mapper = appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), symbol.keyType);
|
|
const propType = instantiateType(templateType, mapper);
|
|
let type = strictNullChecks && symbol.flags & 16777216 /* Optional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(propType, true) : symbol.checkFlags & 524288 /* StripOptional */ ? removeMissingOrUndefinedType(propType) : propType;
|
|
if (!popTypeResolution()) {
|
|
error(currentNode, 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)) : void 0;
|
|
}
|
|
function getTemplateTypeFromMappedType(type) {
|
|
return type.templateType || (type.templateType = type.declaration.type ? instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), true, !!(getMappedTypeModifiers(type) & 4 /* IncludeOptional */)), type.mapper) : errorType);
|
|
}
|
|
function getConstraintDeclarationForMappedType(type) {
|
|
return getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter);
|
|
}
|
|
function isMappedTypeWithKeyofConstraintDeclaration(type) {
|
|
const constraintDeclaration = getConstraintDeclarationForMappedType(type);
|
|
return constraintDeclaration.kind === 195 /* TypeOperator */ && constraintDeclaration.operator === 141 /* KeyOfKeyword */;
|
|
}
|
|
function getModifiersTypeFromMappedType(type) {
|
|
if (!type.modifiersType) {
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper);
|
|
} else {
|
|
const declaredType = getTypeFromMappedTypeNode(type.declaration);
|
|
const constraint = getConstraintTypeFromMappedType(declaredType);
|
|
const extendedConstraint = constraint && constraint.flags & 262144 /* TypeParameter */ ? getConstraintOfTypeParameter(constraint) : constraint;
|
|
type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 /* Index */ ? instantiateType(extendedConstraint.type, type.mapper) : unknownType;
|
|
}
|
|
}
|
|
return type.modifiersType;
|
|
}
|
|
function getMappedTypeModifiers(type) {
|
|
const declaration = type.declaration;
|
|
return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 /* MinusToken */ ? 2 /* ExcludeReadonly */ : 1 /* IncludeReadonly */ : 0) | (declaration.questionToken ? declaration.questionToken.kind === 40 /* MinusToken */ ? 8 /* ExcludeOptional */ : 4 /* IncludeOptional */ : 0);
|
|
}
|
|
function getMappedTypeOptionality(type) {
|
|
const modifiers = getMappedTypeModifiers(type);
|
|
return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
|
|
}
|
|
function getCombinedMappedTypeOptionality(type) {
|
|
const optionality = getMappedTypeOptionality(type);
|
|
const modifiersType = getModifiersTypeFromMappedType(type);
|
|
return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0);
|
|
}
|
|
function isPartialMappedType(type) {
|
|
return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
|
|
}
|
|
function isGenericMappedType(type) {
|
|
if (getObjectFlags(type) & 32 /* Mapped */) {
|
|
const constraint = getConstraintTypeFromMappedType(type);
|
|
if (isGenericIndexType(constraint)) {
|
|
return true;
|
|
}
|
|
const 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 /* Object */) {
|
|
if (type.objectFlags & 4 /* Reference */) {
|
|
resolveTypeReferenceMembers(type);
|
|
} else if (type.objectFlags & 3 /* ClassOrInterface */) {
|
|
resolveClassOrInterfaceMembers(type);
|
|
} else if (type.objectFlags & 1024 /* ReverseMapped */) {
|
|
resolveReverseMappedTypeMembers(type);
|
|
} else if (type.objectFlags & 16 /* Anonymous */) {
|
|
resolveAnonymousTypeMembers(type);
|
|
} else if (type.objectFlags & 32 /* Mapped */) {
|
|
resolveMappedTypeMembers(type);
|
|
} else {
|
|
Debug.fail("Unhandled object type " + Debug.formatObjectFlags(type.objectFlags));
|
|
}
|
|
} else if (type.flags & 1048576 /* Union */) {
|
|
resolveUnionTypeMembers(type);
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
resolveIntersectionTypeMembers(type);
|
|
} else {
|
|
Debug.fail("Unhandled type " + Debug.formatTypeFlags(type.flags));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function getPropertiesOfObjectType(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
return resolveStructuredTypeMembers(type).properties;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getPropertyOfObjectType(type, name) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
const symbol = resolved.members.get(name);
|
|
if (symbol && symbolIsValue(symbol)) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
function getPropertiesOfUnionOrIntersectionType(type) {
|
|
if (!type.resolvedProperties) {
|
|
const members = createSymbolTable();
|
|
for (const current of type.types) {
|
|
for (const prop of getPropertiesOfType(current)) {
|
|
if (!members.has(prop.escapedName)) {
|
|
const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
|
|
if (combinedProp) {
|
|
members.set(prop.escapedName, combinedProp);
|
|
}
|
|
}
|
|
}
|
|
if (type.flags & 1048576 /* Union */ && getIndexInfosOfType(current).length === 0) {
|
|
break;
|
|
}
|
|
}
|
|
type.resolvedProperties = getNamedMembers(members);
|
|
}
|
|
return type.resolvedProperties;
|
|
}
|
|
function getPropertiesOfType(type) {
|
|
type = getReducedApparentType(type);
|
|
return type.flags & 3145728 /* UnionOrIntersection */ ? getPropertiesOfUnionOrIntersectionType(type) : getPropertiesOfObjectType(type);
|
|
}
|
|
function forEachPropertyOfType(type, action) {
|
|
type = getReducedApparentType(type);
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
resolveStructuredTypeMembers(type).members.forEach((symbol, escapedName) => {
|
|
if (isNamedMember(symbol, escapedName)) {
|
|
action(symbol, escapedName);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
|
|
const list = obj.properties;
|
|
return list.some((property) => {
|
|
const nameType = property.name && getLiteralTypeFromPropertyName(property.name);
|
|
const name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : void 0;
|
|
const expected = name === void 0 ? void 0 : getTypeOfPropertyOfType(contextualType, name);
|
|
return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected);
|
|
});
|
|
}
|
|
function getAllPossiblePropertiesOfTypes(types) {
|
|
const unionType = getUnionType(types);
|
|
if (!(unionType.flags & 1048576 /* Union */)) {
|
|
return getAugmentedPropertiesOfType(unionType);
|
|
}
|
|
const props = createSymbolTable();
|
|
for (const memberType of types) {
|
|
for (const { escapedName } of getAugmentedPropertiesOfType(memberType)) {
|
|
if (!props.has(escapedName)) {
|
|
const prop = createUnionOrIntersectionProperty(unionType, escapedName);
|
|
if (prop)
|
|
props.set(escapedName, prop);
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(props.values());
|
|
}
|
|
function getConstraintOfType(type) {
|
|
return type.flags & 262144 /* TypeParameter */ ? getConstraintOfTypeParameter(type) : type.flags & 8388608 /* IndexedAccess */ ? getConstraintOfIndexedAccess(type) : type.flags & 16777216 /* Conditional */ ? getConstraintOfConditionalType(type) : getBaseConstraintOfType(type);
|
|
}
|
|
function getConstraintOfTypeParameter(typeParameter) {
|
|
return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : void 0;
|
|
}
|
|
function getConstraintOfIndexedAccess(type) {
|
|
return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
|
|
}
|
|
function getSimplifiedTypeOrConstraint(type) {
|
|
const simplified = getSimplifiedType(type, false);
|
|
return simplified !== type ? simplified : getConstraintOfType(type);
|
|
}
|
|
function getConstraintFromIndexedAccess(type) {
|
|
if (isMappedTypeGenericIndexedAccess(type)) {
|
|
return substituteIndexedMappedType(type.objectType, type.indexType);
|
|
}
|
|
const indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
|
|
if (indexConstraint && indexConstraint !== type.indexType) {
|
|
const indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags);
|
|
if (indexedAccess) {
|
|
return indexedAccess;
|
|
}
|
|
}
|
|
const objectConstraint = getSimplifiedTypeOrConstraint(type.objectType);
|
|
if (objectConstraint && objectConstraint !== type.objectType) {
|
|
return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType, type.accessFlags);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDefaultConstraintOfConditionalType(type) {
|
|
if (!type.resolvedDefaultConstraint) {
|
|
const trueConstraint = getInferredTrueTypeFromConditionalType(type);
|
|
const falseConstraint = getFalseTypeFromConditionalType(type);
|
|
type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]);
|
|
}
|
|
return type.resolvedDefaultConstraint;
|
|
}
|
|
function getConstraintOfDistributiveConditionalType(type) {
|
|
if (type.root.isDistributive && type.restrictiveInstantiation !== type) {
|
|
const simplified = getSimplifiedType(type.checkType, false);
|
|
const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
|
|
if (constraint && constraint !== type.checkType) {
|
|
const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
|
|
if (!(instantiated.flags & 131072 /* Never */)) {
|
|
return instantiated;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getConstraintFromConditionalType(type) {
|
|
return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type);
|
|
}
|
|
function getConstraintOfConditionalType(type) {
|
|
return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : void 0;
|
|
}
|
|
function getEffectiveConstraintOfIntersection(types, targetIsUnion) {
|
|
let constraints;
|
|
let hasDisjointDomainType = false;
|
|
for (const t of types) {
|
|
if (t.flags & 465829888 /* Instantiable */) {
|
|
let constraint = getConstraintOfType(t);
|
|
while (constraint && constraint.flags & (262144 /* TypeParameter */ | 4194304 /* Index */ | 16777216 /* Conditional */)) {
|
|
constraint = getConstraintOfType(constraint);
|
|
}
|
|
if (constraint) {
|
|
constraints = append(constraints, constraint);
|
|
if (targetIsUnion) {
|
|
constraints = append(constraints, t);
|
|
}
|
|
}
|
|
} else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
|
|
hasDisjointDomainType = true;
|
|
}
|
|
}
|
|
if (constraints && (targetIsUnion || hasDisjointDomainType)) {
|
|
if (hasDisjointDomainType) {
|
|
for (const t of types) {
|
|
if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
|
|
constraints = append(constraints, t);
|
|
}
|
|
}
|
|
}
|
|
return getNormalizedType(getIntersectionType(constraints), false);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getBaseConstraintOfType(type) {
|
|
if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
|
|
const constraint = getResolvedBaseConstraint(type);
|
|
return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : void 0;
|
|
}
|
|
return type.flags & 4194304 /* Index */ ? keyofConstraintType : void 0;
|
|
}
|
|
function getBaseConstraintOrType(type) {
|
|
return getBaseConstraintOfType(type) || type;
|
|
}
|
|
function hasNonCircularBaseConstraint(type) {
|
|
return getResolvedBaseConstraint(type) !== circularConstraintType;
|
|
}
|
|
function getResolvedBaseConstraint(type) {
|
|
if (type.resolvedBaseConstraint) {
|
|
return type.resolvedBaseConstraint;
|
|
}
|
|
const stack = [];
|
|
return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type);
|
|
function getImmediateBaseConstraint(t) {
|
|
if (!t.immediateBaseConstraint) {
|
|
if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
|
|
return circularConstraintType;
|
|
}
|
|
let result;
|
|
const identity2 = getRecursionIdentity(t);
|
|
if (stack.length < 10 || stack.length < 50 && !contains(stack, identity2)) {
|
|
stack.push(identity2);
|
|
result = computeBaseConstraint(getSimplifiedType(t, false));
|
|
stack.pop();
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
const errorNode = getConstraintDeclaration(t);
|
|
if (errorNode) {
|
|
const diagnostic = error(errorNode, Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t));
|
|
if (currentNode && !isNodeDescendantOf(errorNode, currentNode) && !isNodeDescendantOf(currentNode, errorNode)) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(currentNode, Diagnostics.Circularity_originates_in_type_at_this_location));
|
|
}
|
|
}
|
|
}
|
|
result = circularConstraintType;
|
|
}
|
|
t.immediateBaseConstraint = result || noConstraintType;
|
|
}
|
|
return t.immediateBaseConstraint;
|
|
}
|
|
function getBaseConstraint(t) {
|
|
const c = getImmediateBaseConstraint(t);
|
|
return c !== noConstraintType && c !== circularConstraintType ? c : void 0;
|
|
}
|
|
function computeBaseConstraint(t) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getConstraintFromTypeParameter(t);
|
|
return t.isThisType || !constraint ? constraint : getBaseConstraint(constraint);
|
|
}
|
|
if (t.flags & 3145728 /* UnionOrIntersection */) {
|
|
const types = t.types;
|
|
const baseTypes = [];
|
|
let different = false;
|
|
for (const type2 of types) {
|
|
const baseType = getBaseConstraint(type2);
|
|
if (baseType) {
|
|
if (baseType !== type2) {
|
|
different = true;
|
|
}
|
|
baseTypes.push(baseType);
|
|
} else {
|
|
different = true;
|
|
}
|
|
}
|
|
if (!different) {
|
|
return t;
|
|
}
|
|
return t.flags & 1048576 /* Union */ && baseTypes.length === types.length ? getUnionType(baseTypes) : t.flags & 2097152 /* Intersection */ && baseTypes.length ? getIntersectionType(baseTypes) : void 0;
|
|
}
|
|
if (t.flags & 4194304 /* Index */) {
|
|
return keyofConstraintType;
|
|
}
|
|
if (t.flags & 134217728 /* TemplateLiteral */) {
|
|
const types = t.types;
|
|
const constraints = mapDefined(types, getBaseConstraint);
|
|
return constraints.length === types.length ? getTemplateLiteralType(t.texts, constraints) : stringType;
|
|
}
|
|
if (t.flags & 268435456 /* StringMapping */) {
|
|
const constraint = getBaseConstraint(t.type);
|
|
return constraint && constraint !== t.type ? getStringMappingType(t.symbol, constraint) : stringType;
|
|
}
|
|
if (t.flags & 8388608 /* IndexedAccess */) {
|
|
if (isMappedTypeGenericIndexedAccess(t)) {
|
|
return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType));
|
|
}
|
|
const baseObjectType = getBaseConstraint(t.objectType);
|
|
const baseIndexType = getBaseConstraint(t.indexType);
|
|
const baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags);
|
|
return baseIndexedAccess && getBaseConstraint(baseIndexedAccess);
|
|
}
|
|
if (t.flags & 16777216 /* Conditional */) {
|
|
const constraint = getConstraintFromConditionalType(t);
|
|
return constraint && getBaseConstraint(constraint);
|
|
}
|
|
if (t.flags & 33554432 /* Substitution */) {
|
|
return getBaseConstraint(getSubstitutionIntersection(t));
|
|
}
|
|
return t;
|
|
}
|
|
}
|
|
function getApparentTypeOfIntersectionType(type) {
|
|
return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, true));
|
|
}
|
|
function getResolvedTypeParameterDefault(typeParameter) {
|
|
if (!typeParameter.default) {
|
|
if (typeParameter.target) {
|
|
const targetDefault = getResolvedTypeParameterDefault(typeParameter.target);
|
|
typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType;
|
|
} else {
|
|
typeParameter.default = resolvingDefaultType;
|
|
const defaultDeclaration = typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default);
|
|
const defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType;
|
|
if (typeParameter.default === resolvingDefaultType) {
|
|
typeParameter.default = defaultType;
|
|
}
|
|
}
|
|
} else if (typeParameter.default === resolvingDefaultType) {
|
|
typeParameter.default = circularConstraintType;
|
|
}
|
|
return typeParameter.default;
|
|
}
|
|
function getDefaultFromTypeParameter(typeParameter) {
|
|
const defaultType = getResolvedTypeParameterDefault(typeParameter);
|
|
return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : void 0;
|
|
}
|
|
function hasNonCircularTypeParameterDefault(typeParameter) {
|
|
return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType;
|
|
}
|
|
function hasTypeParameterDefault(typeParameter) {
|
|
return !!(typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default));
|
|
}
|
|
function getApparentTypeOfMappedType(type) {
|
|
return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
|
|
}
|
|
function getResolvedApparentTypeOfMappedType(type) {
|
|
const typeVariable = getHomomorphicTypeVariable(type);
|
|
if (typeVariable && !type.declaration.nameType) {
|
|
const constraint = getConstraintOfTypeParameter(typeVariable);
|
|
if (constraint && isArrayOrTupleType(constraint)) {
|
|
return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function isMappedTypeGenericIndexedAccess(type) {
|
|
let objectType;
|
|
return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
|
|
}
|
|
function getApparentType(type) {
|
|
const t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
|
|
return getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
|
|
}
|
|
function getReducedApparentType(type) {
|
|
return getReducedType(getApparentType(getReducedType(type)));
|
|
}
|
|
function createUnionOrIntersectionProperty(containingType, name, skipObjectFunctionPropertyAugment) {
|
|
var _a2, _b;
|
|
let singleProp;
|
|
let propSet;
|
|
let indexTypes;
|
|
const isUnion = containingType.flags & 1048576 /* Union */;
|
|
let optionalFlag;
|
|
let syntheticFlag = 4 /* SyntheticMethod */;
|
|
let checkFlags = isUnion ? 0 : 8 /* Readonly */;
|
|
let mergedInstantiations = false;
|
|
for (const current of containingType.types) {
|
|
const type = getApparentType(current);
|
|
if (!(isErrorType(type) || type.flags & 131072 /* Never */)) {
|
|
const prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
|
|
const modifiers = prop ? getDeclarationModifierFlagsFromSymbol(prop) : 0;
|
|
if (prop) {
|
|
if (prop.flags & 106500 /* ClassMember */) {
|
|
optionalFlag != null ? optionalFlag : optionalFlag = isUnion ? 0 /* None */ : 16777216 /* Optional */;
|
|
if (isUnion) {
|
|
optionalFlag |= prop.flags & 16777216 /* Optional */;
|
|
} else {
|
|
optionalFlag &= prop.flags;
|
|
}
|
|
}
|
|
if (!singleProp) {
|
|
singleProp = prop;
|
|
} else if (prop !== singleProp) {
|
|
const isInstantiation = (getTargetSymbol(prop) || prop) === (getTargetSymbol(singleProp) || singleProp);
|
|
if (isInstantiation && compareProperties(singleProp, prop, (a, b) => a === b ? -1 /* True */ : 0 /* False */) === -1 /* True */) {
|
|
mergedInstantiations = !!singleProp.parent && !!length(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(singleProp.parent));
|
|
} else {
|
|
if (!propSet) {
|
|
propSet = /* @__PURE__ */ new Map();
|
|
propSet.set(getSymbolId(singleProp), singleProp);
|
|
}
|
|
const id = getSymbolId(prop);
|
|
if (!propSet.has(id)) {
|
|
propSet.set(id, prop);
|
|
}
|
|
}
|
|
}
|
|
if (isUnion && isReadonlySymbol(prop)) {
|
|
checkFlags |= 8 /* Readonly */;
|
|
} else if (!isUnion && !isReadonlySymbol(prop)) {
|
|
checkFlags &= ~8 /* Readonly */;
|
|
}
|
|
checkFlags |= (!(modifiers & 24 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 16 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 8 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 32 /* Static */ ? 2048 /* ContainsStatic */ : 0);
|
|
if (!isPrototypeProperty(prop)) {
|
|
syntheticFlag = 2 /* SyntheticProperty */;
|
|
}
|
|
} else if (isUnion) {
|
|
const indexInfo = !isLateBoundName(name) && getApplicableIndexInfoForName(type, name);
|
|
if (indexInfo) {
|
|
checkFlags |= 32 /* WritePartial */ | (indexInfo.isReadonly ? 8 /* Readonly */ : 0);
|
|
indexTypes = append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type);
|
|
} else if (isObjectLiteralType(type) && !(getObjectFlags(type) & 2097152 /* ContainsSpread */)) {
|
|
checkFlags |= 32 /* WritePartial */;
|
|
indexTypes = append(indexTypes, undefinedType);
|
|
} else {
|
|
checkFlags |= 16 /* ReadPartial */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!singleProp || isUnion && (propSet || checkFlags & 48 /* Partial */) && checkFlags & (1024 /* ContainsPrivate */ | 512 /* ContainsProtected */) && !(propSet && getCommonDeclarationsOfSymbols(arrayFrom(propSet.values())))) {
|
|
return void 0;
|
|
}
|
|
if (!propSet && !(checkFlags & 16 /* ReadPartial */) && !indexTypes) {
|
|
if (mergedInstantiations) {
|
|
const clone2 = createSymbolWithType(singleProp, singleProp.type);
|
|
clone2.parent = (_b = (_a2 = singleProp.valueDeclaration) == null ? void 0 : _a2.symbol) == null ? void 0 : _b.parent;
|
|
clone2.containingType = containingType;
|
|
clone2.mapper = singleProp.mapper;
|
|
return clone2;
|
|
} else {
|
|
return singleProp;
|
|
}
|
|
}
|
|
const props = propSet ? arrayFrom(propSet.values()) : [singleProp];
|
|
let declarations;
|
|
let firstType;
|
|
let nameType;
|
|
const propTypes = [];
|
|
let writeTypes;
|
|
let firstValueDeclaration;
|
|
let hasNonUniformValueDeclaration = false;
|
|
for (const prop of props) {
|
|
if (!firstValueDeclaration) {
|
|
firstValueDeclaration = prop.valueDeclaration;
|
|
} else if (prop.valueDeclaration && prop.valueDeclaration !== firstValueDeclaration) {
|
|
hasNonUniformValueDeclaration = true;
|
|
}
|
|
declarations = addRange(declarations, prop.declarations);
|
|
const type = getTypeOfSymbol(prop);
|
|
if (!firstType) {
|
|
firstType = type;
|
|
nameType = getSymbolLinks(prop).nameType;
|
|
}
|
|
const writeType = getWriteTypeOfSymbol(prop);
|
|
if (writeTypes || writeType !== type) {
|
|
writeTypes = append(!writeTypes ? propTypes.slice() : writeTypes, writeType);
|
|
} else if (type !== firstType) {
|
|
checkFlags |= 64 /* HasNonUniformType */;
|
|
}
|
|
if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) {
|
|
checkFlags |= 128 /* HasLiteralType */;
|
|
}
|
|
if (type.flags & 131072 /* Never */ && type !== uniqueLiteralType) {
|
|
checkFlags |= 131072 /* HasNeverType */;
|
|
}
|
|
propTypes.push(type);
|
|
}
|
|
addRange(propTypes, indexTypes);
|
|
const result = createSymbol(4 /* Property */ | (optionalFlag != null ? optionalFlag : 0), name, syntheticFlag | checkFlags);
|
|
result.containingType = containingType;
|
|
if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
|
|
result.valueDeclaration = firstValueDeclaration;
|
|
if (firstValueDeclaration.symbol.parent) {
|
|
result.parent = firstValueDeclaration.symbol.parent;
|
|
}
|
|
}
|
|
result.declarations = declarations;
|
|
result.nameType = nameType;
|
|
if (propTypes.length > 2) {
|
|
result.checkFlags |= 65536 /* 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;
|
|
}
|
|
function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
|
|
var _a2, _b;
|
|
let property = ((_a2 = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a2.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
|
|
if (!property) {
|
|
property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
|
|
if (property) {
|
|
const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
|
|
properties.set(name, property);
|
|
}
|
|
}
|
|
return property;
|
|
}
|
|
function getCommonDeclarationsOfSymbols(symbols) {
|
|
let commonDeclarations;
|
|
for (const symbol of symbols) {
|
|
if (!symbol.declarations) {
|
|
return void 0;
|
|
}
|
|
if (!commonDeclarations) {
|
|
commonDeclarations = new Set(symbol.declarations);
|
|
continue;
|
|
}
|
|
commonDeclarations.forEach((declaration) => {
|
|
if (!contains(symbol.declarations, declaration)) {
|
|
commonDeclarations.delete(declaration);
|
|
}
|
|
});
|
|
if (commonDeclarations.size === 0) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return commonDeclarations;
|
|
}
|
|
function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) {
|
|
const property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
|
|
return property && !(getCheckFlags(property) & 16 /* ReadPartial */) ? property : void 0;
|
|
}
|
|
function getReducedType(type) {
|
|
if (type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */) {
|
|
return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type));
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
if (!(type.objectFlags & 16777216 /* IsNeverIntersectionComputed */)) {
|
|
type.objectFlags |= 16777216 /* IsNeverIntersectionComputed */ | (some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 33554432 /* IsNeverIntersection */ : 0);
|
|
}
|
|
return type.objectFlags & 33554432 /* IsNeverIntersection */ ? neverType : type;
|
|
}
|
|
return type;
|
|
}
|
|
function getReducedUnionType(unionType) {
|
|
const reducedTypes = sameMap(unionType.types, getReducedType);
|
|
if (reducedTypes === unionType.types) {
|
|
return unionType;
|
|
}
|
|
const reduced = getUnionType(reducedTypes);
|
|
if (reduced.flags & 1048576 /* Union */) {
|
|
reduced.resolvedReducedType = reduced;
|
|
}
|
|
return reduced;
|
|
}
|
|
function isNeverReducedProperty(prop) {
|
|
return isDiscriminantWithNeverType(prop) || isConflictingPrivateProperty(prop);
|
|
}
|
|
function isDiscriminantWithNeverType(prop) {
|
|
return !(prop.flags & 16777216 /* Optional */) && (getCheckFlags(prop) & (192 /* Discriminant */ | 131072 /* HasNeverType */)) === 192 /* Discriminant */ && !!(getTypeOfSymbol(prop).flags & 131072 /* Never */);
|
|
}
|
|
function isConflictingPrivateProperty(prop) {
|
|
return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
|
|
}
|
|
function elaborateNeverIntersection(errorInfo, type) {
|
|
if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
|
|
const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
|
|
if (neverProp) {
|
|
return chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents,
|
|
typeToString(type, void 0, 536870912 /* NoTypeReduction */),
|
|
symbolToString(neverProp)
|
|
);
|
|
}
|
|
const privateProp = find(getPropertiesOfUnionOrIntersectionType(type), isConflictingPrivateProperty);
|
|
if (privateProp) {
|
|
return chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some,
|
|
typeToString(type, void 0, 536870912 /* NoTypeReduction */),
|
|
symbolToString(privateProp)
|
|
);
|
|
}
|
|
}
|
|
return errorInfo;
|
|
}
|
|
function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment, includeTypeOnlyMembers) {
|
|
type = getReducedApparentType(type);
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
const symbol = resolved.members.get(name);
|
|
if (symbol && symbolIsValue(symbol, includeTypeOnlyMembers)) {
|
|
return symbol;
|
|
}
|
|
if (skipObjectFunctionPropertyAugment)
|
|
return void 0;
|
|
const functionType = resolved === anyFunctionType ? globalFunctionType : resolved.callSignatures.length ? globalCallableFunctionType : resolved.constructSignatures.length ? globalNewableFunctionType : void 0;
|
|
if (functionType) {
|
|
const symbol2 = getPropertyOfObjectType(functionType, name);
|
|
if (symbol2) {
|
|
return symbol2;
|
|
}
|
|
}
|
|
return getPropertyOfObjectType(globalObjectType, name);
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSignaturesOfStructuredType(type, kind) {
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return kind === 0 /* Call */ ? resolved.callSignatures : resolved.constructSignatures;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getSignaturesOfType(type, kind) {
|
|
return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
|
|
}
|
|
function findIndexInfo(indexInfos, keyType) {
|
|
return find(indexInfos, (info) => info.keyType === keyType);
|
|
}
|
|
function findApplicableIndexInfo(indexInfos, keyType) {
|
|
let stringIndexInfo;
|
|
let applicableInfo;
|
|
let applicableInfos;
|
|
for (const info of indexInfos) {
|
|
if (info.keyType === stringType) {
|
|
stringIndexInfo = info;
|
|
} else if (isApplicableIndexType(keyType, info.keyType)) {
|
|
if (!applicableInfo) {
|
|
applicableInfo = info;
|
|
} else {
|
|
(applicableInfos || (applicableInfos = [applicableInfo])).push(info);
|
|
}
|
|
}
|
|
}
|
|
return applicableInfos ? createIndexInfo(
|
|
unknownType,
|
|
getIntersectionType(map(applicableInfos, (info) => info.type)),
|
|
reduceLeft(applicableInfos, (isReadonly, info) => isReadonly && info.isReadonly, true)
|
|
) : applicableInfo ? applicableInfo : stringIndexInfo && isApplicableIndexType(keyType, stringType) ? stringIndexInfo : void 0;
|
|
}
|
|
function isApplicableIndexType(source, target) {
|
|
return isTypeAssignableTo(source, target) || target === stringType && isTypeAssignableTo(source, numberType) || target === numberType && (source === numericStringType || !!(source.flags & 128 /* StringLiteral */) && isNumericLiteralName(source.value));
|
|
}
|
|
function getIndexInfosOfStructuredType(type) {
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return resolved.indexInfos;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getIndexInfosOfType(type) {
|
|
return getIndexInfosOfStructuredType(getReducedApparentType(type));
|
|
}
|
|
function getIndexInfoOfType(type, keyType) {
|
|
return findIndexInfo(getIndexInfosOfType(type), keyType);
|
|
}
|
|
function getIndexTypeOfType(type, keyType) {
|
|
var _a2;
|
|
return (_a2 = getIndexInfoOfType(type, keyType)) == null ? void 0 : _a2.type;
|
|
}
|
|
function getApplicableIndexInfos(type, keyType) {
|
|
return getIndexInfosOfType(type).filter((info) => isApplicableIndexType(keyType, info.keyType));
|
|
}
|
|
function getApplicableIndexInfo(type, keyType) {
|
|
return findApplicableIndexInfo(getIndexInfosOfType(type), keyType);
|
|
}
|
|
function getApplicableIndexInfoForName(type, name) {
|
|
return getApplicableIndexInfo(type, isLateBoundName(name) ? esSymbolType : getStringLiteralType(unescapeLeadingUnderscores(name)));
|
|
}
|
|
function getTypeParametersFromDeclaration(declaration) {
|
|
var _a2;
|
|
let result;
|
|
for (const node of getEffectiveTypeParameterDeclarations(declaration)) {
|
|
result = appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol));
|
|
}
|
|
return (result == null ? void 0 : result.length) ? result : isFunctionDeclaration(declaration) ? (_a2 = getSignatureOfTypeTag(declaration)) == null ? void 0 : _a2.typeParameters : void 0;
|
|
}
|
|
function symbolsToArray(symbols) {
|
|
const result = [];
|
|
symbols.forEach((symbol, id) => {
|
|
if (!isReservedMemberName(id)) {
|
|
result.push(symbol);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function isJSDocOptionalParameter(node) {
|
|
return isInJSFile(node) && (node.type && node.type.kind === 319 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(({ isBracketed, typeExpression }) => isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* JSDocOptionalType */));
|
|
}
|
|
function tryFindAmbientModule(moduleName, withAugmentations) {
|
|
if (isExternalModuleNameRelative(moduleName)) {
|
|
return void 0;
|
|
}
|
|
const symbol = getSymbol(globals, '"' + moduleName + '"', 512 /* ValueModule */);
|
|
return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
|
|
}
|
|
function isOptionalParameter(node) {
|
|
if (hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) {
|
|
return true;
|
|
}
|
|
if (node.initializer) {
|
|
const signature = getSignatureFromDeclaration(node.parent);
|
|
const parameterIndex = node.parent.parameters.indexOf(node);
|
|
Debug.assert(parameterIndex >= 0);
|
|
return parameterIndex >= getMinArgumentCount(signature, 1 /* StrongArityForUntypedJS */ | 2 /* VoidIsNonOptional */);
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(node.parent);
|
|
if (iife) {
|
|
return !node.type && !node.dotDotDotToken && node.parent.parameters.indexOf(node) >= iife.arguments.length;
|
|
}
|
|
return false;
|
|
}
|
|
function isOptionalPropertyDeclaration(node) {
|
|
return isPropertyDeclaration(node) && !hasAccessorModifier(node) && node.questionToken;
|
|
}
|
|
function createTypePredicate(kind, parameterName, parameterIndex, type) {
|
|
return { kind, parameterName, parameterIndex, type };
|
|
}
|
|
function getMinTypeArgumentCount(typeParameters) {
|
|
let minTypeArgumentCount = 0;
|
|
if (typeParameters) {
|
|
for (let i = 0; i < typeParameters.length; i++) {
|
|
if (!hasTypeParameterDefault(typeParameters[i])) {
|
|
minTypeArgumentCount = i + 1;
|
|
}
|
|
}
|
|
}
|
|
return minTypeArgumentCount;
|
|
}
|
|
function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {
|
|
const numTypeParameters = length(typeParameters);
|
|
if (!numTypeParameters) {
|
|
return [];
|
|
}
|
|
const numTypeArguments = length(typeArguments);
|
|
if (isJavaScriptImplicitAny || numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters) {
|
|
const result = typeArguments ? typeArguments.slice() : [];
|
|
for (let i = numTypeArguments; i < numTypeParameters; i++) {
|
|
result[i] = errorType;
|
|
}
|
|
const baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny);
|
|
for (let i = numTypeArguments; i < numTypeParameters; i++) {
|
|
let 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) {
|
|
const links = getNodeLinks(declaration);
|
|
if (!links.resolvedSignature) {
|
|
const parameters = [];
|
|
let flags = 0 /* None */;
|
|
let minArgumentCount = 0;
|
|
let thisParameter;
|
|
let hasThisParameter = false;
|
|
const iife = getImmediatelyInvokedFunctionExpression(declaration);
|
|
const isJSConstructSignature = isJSDocConstructSignature(declaration);
|
|
const isUntypedSignatureInJSFile = !iife && isInJSFile(declaration) && isValueSignatureDeclaration(declaration) && !hasJSDocParameterTags(declaration) && !getJSDocType(declaration);
|
|
if (isUntypedSignatureInJSFile) {
|
|
flags |= 32 /* IsUntypedSignatureInJSFile */;
|
|
}
|
|
for (let i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) {
|
|
const param = declaration.parameters[i];
|
|
let paramSymbol = param.symbol;
|
|
const type = isJSDocParameterTag(param) ? param.typeExpression && param.typeExpression.type : param.type;
|
|
if (paramSymbol && !!(paramSymbol.flags & 4 /* Property */) && !isBindingPattern(param.name)) {
|
|
const resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551 /* Value */, void 0, void 0, false);
|
|
paramSymbol = resolvedSymbol;
|
|
}
|
|
if (i === 0 && paramSymbol.escapedName === "this" /* This */) {
|
|
hasThisParameter = true;
|
|
thisParameter = param.symbol;
|
|
} else {
|
|
parameters.push(paramSymbol);
|
|
}
|
|
if (type && type.kind === 198 /* LiteralType */) {
|
|
flags |= 2 /* HasLiteralTypes */;
|
|
}
|
|
const isOptionalParameter2 = isOptionalJSDocPropertyLikeTag(param) || param.initializer || param.questionToken || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type || isJSDocOptionalParameter(param);
|
|
if (!isOptionalParameter2) {
|
|
minArgumentCount = parameters.length;
|
|
}
|
|
}
|
|
if ((declaration.kind === 174 /* GetAccessor */ || declaration.kind === 175 /* SetAccessor */) && hasBindableName(declaration) && (!hasThisParameter || !thisParameter)) {
|
|
const otherKind = declaration.kind === 174 /* GetAccessor */ ? 175 /* SetAccessor */ : 174 /* GetAccessor */;
|
|
const other = getDeclarationOfKind(getSymbolOfNode(declaration), otherKind);
|
|
if (other) {
|
|
thisParameter = getAnnotatedAccessorThisParameter(other);
|
|
}
|
|
}
|
|
const classType = declaration.kind === 173 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)) : void 0;
|
|
const typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration);
|
|
if (hasRestParameter(declaration) || isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
|
|
flags |= 1 /* HasRestParameter */;
|
|
}
|
|
if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 256 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 256 /* Abstract */)) {
|
|
flags |= 4 /* Abstract */;
|
|
}
|
|
links.resolvedSignature = createSignature(
|
|
declaration,
|
|
typeParameters,
|
|
thisParameter,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
minArgumentCount,
|
|
flags
|
|
);
|
|
}
|
|
return links.resolvedSignature;
|
|
}
|
|
function maybeAddJsSyntheticRestParameter(declaration, parameters) {
|
|
if (isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) {
|
|
return false;
|
|
}
|
|
const lastParam = lastOrUndefined(declaration.parameters);
|
|
const lastParamTags = lastParam ? getJSDocParameterTags(lastParam) : getJSDocTags(declaration).filter(isJSDocParameterTag);
|
|
const lastParamVariadicType = firstDefined(lastParamTags, (p) => p.typeExpression && isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : void 0);
|
|
const syntheticArgsSymbol = createSymbol(3 /* Variable */, "args", 32768 /* RestParameter */);
|
|
if (lastParamVariadicType) {
|
|
syntheticArgsSymbol.type = createArrayType(getTypeFromTypeNode(lastParamVariadicType.type));
|
|
} else {
|
|
syntheticArgsSymbol.checkFlags |= 65536 /* DeferredType */;
|
|
syntheticArgsSymbol.deferralParent = neverType;
|
|
syntheticArgsSymbol.deferralConstituents = [anyArrayType];
|
|
syntheticArgsSymbol.deferralWriteConstituents = [anyArrayType];
|
|
}
|
|
if (lastParamVariadicType) {
|
|
parameters.pop();
|
|
}
|
|
parameters.push(syntheticArgsSymbol);
|
|
return true;
|
|
}
|
|
function getSignatureOfTypeTag(node) {
|
|
if (!(isInJSFile(node) && isFunctionLikeDeclaration(node)))
|
|
return void 0;
|
|
const typeTag = getJSDocTypeTag(node);
|
|
return (typeTag == null ? void 0 : typeTag.typeExpression) && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
|
|
}
|
|
function getParameterTypeOfTypeTag(func, parameter) {
|
|
const signature = getSignatureOfTypeTag(func);
|
|
if (!signature)
|
|
return void 0;
|
|
const pos = func.parameters.indexOf(parameter);
|
|
return parameter.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
|
|
}
|
|
function getReturnTypeOfTypeTag(node) {
|
|
const signature = getSignatureOfTypeTag(node);
|
|
return signature && getReturnTypeOfSignature(signature);
|
|
}
|
|
function containsArgumentsReference(declaration) {
|
|
const links = getNodeLinks(declaration);
|
|
if (links.containsArgumentsReference === void 0) {
|
|
if (links.flags & 512 /* 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 /* Identifier */:
|
|
return node.escapedText === argumentsSymbol.escapedName && getReferencedValueSymbol(node) === argumentsSymbol;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return node.name.kind === 164 /* ComputedPropertyName */ && traverse(node.name);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return traverse(node.expression);
|
|
case 299 /* PropertyAssignment */:
|
|
return traverse(node.initializer);
|
|
default:
|
|
return !nodeStartsNewLexicalEnvironment(node) && !isPartOfTypeNode(node) && !!forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
function getSignaturesOfSymbol(symbol) {
|
|
if (!symbol || !symbol.declarations)
|
|
return emptyArray;
|
|
const result = [];
|
|
for (let i = 0; i < symbol.declarations.length; i++) {
|
|
const decl = symbol.declarations[i];
|
|
if (!isFunctionLike(decl))
|
|
continue;
|
|
if (i > 0 && decl.body) {
|
|
const previous = symbol.declarations[i - 1];
|
|
if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) {
|
|
continue;
|
|
}
|
|
}
|
|
result.push(
|
|
!isFunctionExpressionOrArrowFunction(decl) && !isObjectLiteralMethod(decl) && getSignatureOfTypeTag(decl) || getSignatureFromDeclaration(decl)
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
function resolveExternalModuleTypeByLiteral(name) {
|
|
const moduleSym = resolveExternalModuleName(name, name);
|
|
if (moduleSym) {
|
|
const 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) {
|
|
const 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 {
|
|
const type = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
|
|
let jsdocPredicate;
|
|
if (!type) {
|
|
const jsdocSignature = getSignatureOfTypeTag(signature.declaration);
|
|
if (jsdocSignature && signature !== jsdocSignature) {
|
|
jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
|
|
}
|
|
}
|
|
signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
|
|
}
|
|
Debug.assert(!!signature.resolvedTypePredicate);
|
|
}
|
|
return signature.resolvedTypePredicate === noTypePredicate ? void 0 : signature.resolvedTypePredicate;
|
|
}
|
|
function createTypePredicateFromTypePredicateNode(node, signature) {
|
|
const parameterName = node.parameterName;
|
|
const type = node.type && getTypeFromTypeNode(node.type);
|
|
return parameterName.kind === 194 /* ThisType */ ? createTypePredicate(node.assertsModifier ? 2 /* AssertsThis */ : 0 /* This */, void 0, void 0, type) : createTypePredicate(
|
|
node.assertsModifier ? 3 /* AssertsIdentifier */ : 1 /* Identifier */,
|
|
parameterName.escapedText,
|
|
findIndex(signature.parameters, (p) => p.escapedName === parameterName.escapedText),
|
|
type
|
|
);
|
|
}
|
|
function getUnionOrIntersectionType(types, kind, unionReduction) {
|
|
return kind !== 2097152 /* Intersection */ ? getUnionType(types, unionReduction) : getIntersectionType(types);
|
|
}
|
|
function getReturnTypeOfSignature(signature) {
|
|
if (!signature.resolvedReturnType) {
|
|
if (!pushTypeResolution(signature, 3 /* ResolvedReturnType */)) {
|
|
return errorType;
|
|
}
|
|
let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) : signature.compositeSignatures ? instantiateType(getUnionOrIntersectionType(map(signature.compositeSignatures, getReturnTypeOfSignature), signature.compositeKind, 2 /* Subtype */), signature.mapper) : getReturnTypeFromAnnotation(signature.declaration) || (nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration));
|
|
if (signature.flags & 8 /* IsInnerCallChain */) {
|
|
type = addOptionalTypeMarker(type);
|
|
} else if (signature.flags & 16 /* IsOuterCallChain */) {
|
|
type = getOptionalType(type);
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (signature.declaration) {
|
|
const typeNode = getEffectiveReturnTypeNode(signature.declaration);
|
|
if (typeNode) {
|
|
error(typeNode, Diagnostics.Return_type_annotation_circularly_references_itself);
|
|
} else if (noImplicitAny) {
|
|
const declaration = signature.declaration;
|
|
const name = getNameOfDeclaration(declaration);
|
|
if (name) {
|
|
error(name, 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, declarationNameToString(name));
|
|
} else {
|
|
error(declaration, 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 /* Constructor */) {
|
|
return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
|
|
}
|
|
if (isJSDocConstructSignature(declaration)) {
|
|
return getTypeFromTypeNode(declaration.parameters[0].type);
|
|
}
|
|
const typeNode = getEffectiveReturnTypeNode(declaration);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
if (declaration.kind === 174 /* GetAccessor */ && hasBindableName(declaration)) {
|
|
const jsDocType = isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration);
|
|
if (jsDocType) {
|
|
return jsDocType;
|
|
}
|
|
const setter = getDeclarationOfKind(getSymbolOfNode(declaration), 175 /* SetAccessor */);
|
|
const setterType = getAnnotatedAccessorType(setter);
|
|
if (setterType) {
|
|
return setterType;
|
|
}
|
|
}
|
|
return getReturnTypeOfTypeTag(declaration);
|
|
}
|
|
function isResolvingReturnTypeOfSignature(signature) {
|
|
return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3 /* ResolvedReturnType */) >= 0;
|
|
}
|
|
function getRestTypeOfSignature(signature) {
|
|
return tryGetRestTypeOfSignature(signature) || anyType;
|
|
}
|
|
function tryGetRestTypeOfSignature(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
const restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType;
|
|
return restType && getIndexTypeOfType(restType, numberType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) {
|
|
const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript));
|
|
if (inferredTypeParameters) {
|
|
const returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature));
|
|
if (returnSignature) {
|
|
const newReturnSignature = cloneSignature(returnSignature);
|
|
newReturnSignature.typeParameters = inferredTypeParameters;
|
|
const newInstantiatedSignature = cloneSignature(instantiatedSignature);
|
|
newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature);
|
|
return newInstantiatedSignature;
|
|
}
|
|
}
|
|
return instantiatedSignature;
|
|
}
|
|
function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) {
|
|
const instantiations = signature.instantiations || (signature.instantiations = /* @__PURE__ */ new Map());
|
|
const id = getTypeListId(typeArguments);
|
|
let 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), 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) {
|
|
return instantiateSignature(signature, createTypeEraser(signature.typeParameters), true);
|
|
}
|
|
function getCanonicalSignature(signature) {
|
|
return signature.typeParameters ? signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) : signature;
|
|
}
|
|
function createCanonicalSignature(signature) {
|
|
return getSignatureInstantiation(
|
|
signature,
|
|
map(signature.typeParameters, (tp) => tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp),
|
|
isInJSFile(signature.declaration)
|
|
);
|
|
}
|
|
function getBaseSignature(signature) {
|
|
const typeParameters = signature.typeParameters;
|
|
if (typeParameters) {
|
|
if (signature.baseSignatureCache) {
|
|
return signature.baseSignatureCache;
|
|
}
|
|
const typeEraser = createTypeEraser(typeParameters);
|
|
const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
|
|
let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
|
|
for (let i = 0; i < typeParameters.length - 1; i++) {
|
|
baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
|
|
}
|
|
baseConstraints = instantiateTypes(baseConstraints, typeEraser);
|
|
return signature.baseSignatureCache = instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), true);
|
|
}
|
|
return signature;
|
|
}
|
|
function getOrCreateTypeFromSignature(signature) {
|
|
var _a2;
|
|
if (!signature.isolatedSignatureType) {
|
|
const kind = (_a2 = signature.declaration) == null ? void 0 : _a2.kind;
|
|
const isConstructor = kind === void 0 || kind === 173 /* Constructor */ || kind === 177 /* ConstructSignature */ || kind === 182 /* ConstructorType */;
|
|
const type = createObjectType(16 /* Anonymous */);
|
|
type.members = emptySymbols;
|
|
type.properties = emptyArray;
|
|
type.callSignatures = !isConstructor ? [signature] : emptyArray;
|
|
type.constructSignatures = isConstructor ? [signature] : emptyArray;
|
|
type.indexInfos = emptyArray;
|
|
signature.isolatedSignatureType = type;
|
|
}
|
|
return signature.isolatedSignatureType;
|
|
}
|
|
function getIndexSymbol(symbol) {
|
|
return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : void 0;
|
|
}
|
|
function getIndexSymbolFromSymbolTable(symbolTable) {
|
|
return symbolTable.get("__index" /* Index */);
|
|
}
|
|
function createIndexInfo(keyType, type, isReadonly, declaration) {
|
|
return { keyType, type, isReadonly, declaration };
|
|
}
|
|
function getIndexInfosOfSymbol(symbol) {
|
|
const indexSymbol = getIndexSymbol(symbol);
|
|
return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol) : emptyArray;
|
|
}
|
|
function getIndexInfosOfIndexSymbol(indexSymbol) {
|
|
if (indexSymbol.declarations) {
|
|
const indexInfos = [];
|
|
for (const declaration of indexSymbol.declarations) {
|
|
if (declaration.parameters.length === 1) {
|
|
const parameter = declaration.parameters[0];
|
|
if (parameter.type) {
|
|
forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
|
|
if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
|
|
indexInfos.push(createIndexInfo(
|
|
keyType,
|
|
declaration.type ? getTypeFromTypeNode(declaration.type) : anyType,
|
|
hasEffectiveModifier(declaration, 64 /* Readonly */),
|
|
declaration
|
|
));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return indexInfos;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function isValidIndexKeyType(type) {
|
|
return !!(type.flags & (4 /* String */ | 8 /* Number */ | 4096 /* ESSymbol */)) || isPatternLiteralType(type) || !!(type.flags & 2097152 /* Intersection */) && !isGenericType(type) && some(type.types, isValidIndexKeyType);
|
|
}
|
|
function getConstraintDeclaration(type) {
|
|
return mapDefined(filter(type.symbol && type.symbol.declarations, isTypeParameterDeclaration), getEffectiveConstraintOfTypeParameter)[0];
|
|
}
|
|
function getInferredTypeParameterConstraint(typeParameter, omitTypeReferences) {
|
|
var _a2;
|
|
let inferences;
|
|
if ((_a2 = typeParameter.symbol) == null ? void 0 : _a2.declarations) {
|
|
for (const declaration of typeParameter.symbol.declarations) {
|
|
if (declaration.parent.kind === 192 /* InferType */) {
|
|
const [childTypeParameter = declaration.parent, grandParent] = walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent);
|
|
if (grandParent.kind === 180 /* TypeReference */ && !omitTypeReferences) {
|
|
const typeReference = grandParent;
|
|
const typeParameters = getTypeParametersForTypeReference(typeReference);
|
|
if (typeParameters) {
|
|
const index = typeReference.typeArguments.indexOf(childTypeParameter);
|
|
if (index < typeParameters.length) {
|
|
const declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
|
|
if (declaredConstraint) {
|
|
const mapper = makeDeferredTypeMapper(typeParameters, typeParameters.map((_, index2) => () => {
|
|
return getEffectiveTypeArgumentAtIndex(typeReference, typeParameters, index2);
|
|
}));
|
|
const constraint = instantiateType(declaredConstraint, mapper);
|
|
if (constraint !== typeParameter) {
|
|
inferences = append(inferences, constraint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (grandParent.kind === 166 /* Parameter */ && grandParent.dotDotDotToken || grandParent.kind === 188 /* RestType */ || grandParent.kind === 199 /* NamedTupleMember */ && grandParent.dotDotDotToken) {
|
|
inferences = append(inferences, createArrayType(unknownType));
|
|
} else if (grandParent.kind === 201 /* TemplateLiteralTypeSpan */) {
|
|
inferences = append(inferences, stringType);
|
|
} else if (grandParent.kind === 165 /* TypeParameter */ && grandParent.parent.kind === 197 /* MappedType */) {
|
|
inferences = append(inferences, keyofConstraintType);
|
|
} else if (grandParent.kind === 197 /* MappedType */ && grandParent.type && skipParentheses(grandParent.type) === declaration.parent && grandParent.parent.kind === 191 /* ConditionalType */ && grandParent.parent.extendsType === grandParent && grandParent.parent.checkType.kind === 197 /* MappedType */ && grandParent.parent.checkType.type) {
|
|
const checkMappedType2 = grandParent.parent.checkType;
|
|
const nodeType = getTypeFromTypeNode(checkMappedType2.type);
|
|
inferences = append(inferences, instantiateType(
|
|
nodeType,
|
|
makeUnaryTypeMapper(getDeclaredTypeOfTypeParameter(getSymbolOfNode(checkMappedType2.typeParameter)), checkMappedType2.typeParameter.constraint ? getTypeFromTypeNode(checkMappedType2.typeParameter.constraint) : keyofConstraintType)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return inferences && getIntersectionType(inferences);
|
|
}
|
|
function getConstraintFromTypeParameter(typeParameter) {
|
|
if (!typeParameter.constraint) {
|
|
if (typeParameter.target) {
|
|
const targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
|
|
typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
|
|
} else {
|
|
const constraintDeclaration = getConstraintDeclaration(typeParameter);
|
|
if (!constraintDeclaration) {
|
|
typeParameter.constraint = getInferredTypeParameterConstraint(typeParameter) || noConstraintType;
|
|
} else {
|
|
let type = getTypeFromTypeNode(constraintDeclaration);
|
|
if (type.flags & 1 /* Any */ && !isErrorType(type)) {
|
|
type = constraintDeclaration.parent.parent.kind === 197 /* MappedType */ ? keyofConstraintType : unknownType;
|
|
}
|
|
typeParameter.constraint = type;
|
|
}
|
|
}
|
|
}
|
|
return typeParameter.constraint === noConstraintType ? void 0 : typeParameter.constraint;
|
|
}
|
|
function getParentSymbolOfTypeParameter(typeParameter) {
|
|
const tp = getDeclarationOfKind(typeParameter.symbol, 165 /* TypeParameter */);
|
|
const host2 = isJSDocTemplateTag(tp.parent) ? getEffectiveContainerForJSDocTemplateTag(tp.parent) : tp.parent;
|
|
return host2 && getSymbolOfNode(host2);
|
|
}
|
|
function getTypeListId(types) {
|
|
let result = "";
|
|
if (types) {
|
|
const length2 = types.length;
|
|
let i = 0;
|
|
while (i < length2) {
|
|
const startId = types[i].id;
|
|
let count = 1;
|
|
while (i + count < length2 && 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 ? `@${getSymbolId(aliasSymbol)}` + (aliasTypeArguments ? `:${getTypeListId(aliasTypeArguments)}` : "") : "";
|
|
}
|
|
function getPropagatingFlagsOfTypes(types, excludeKinds) {
|
|
let result = 0;
|
|
for (const type of types) {
|
|
if (excludeKinds === void 0 || !(type.flags & excludeKinds)) {
|
|
result |= getObjectFlags(type);
|
|
}
|
|
}
|
|
return result & 458752 /* PropagatingFlags */;
|
|
}
|
|
function createTypeReference(target, typeArguments) {
|
|
const id = getTypeListId(typeArguments);
|
|
let type = target.instantiations.get(id);
|
|
if (!type) {
|
|
type = createObjectType(4 /* 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) {
|
|
const type = createTypeWithSymbol(source.flags, 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);
|
|
const localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
aliasTypeArguments = mapper ? instantiateTypes(localAliasTypeArguments, mapper) : localAliasTypeArguments;
|
|
}
|
|
const type = createObjectType(4 /* Reference */, target.symbol);
|
|
type.target = target;
|
|
type.node = node;
|
|
type.mapper = mapper;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
return type;
|
|
}
|
|
function getTypeArguments(type) {
|
|
var _a2, _b;
|
|
if (!type.resolvedTypeArguments) {
|
|
if (!pushTypeResolution(type, 6 /* ResolvedTypeArguments */)) {
|
|
return ((_a2 = type.target.localTypeParameters) == null ? void 0 : _a2.map(() => errorType)) || emptyArray;
|
|
}
|
|
const node = type.node;
|
|
const typeArguments = !node ? emptyArray : node.kind === 180 /* TypeReference */ ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) : node.kind === 185 /* ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode);
|
|
if (popTypeResolution()) {
|
|
type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
|
|
} else {
|
|
type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) == null ? void 0 : _b.map(() => errorType)) || emptyArray;
|
|
error(
|
|
type.node || currentNode,
|
|
type.target.symbol ? Diagnostics.Type_arguments_for_0_circularly_reference_themselves : Diagnostics.Tuple_type_arguments_circularly_reference_themselves,
|
|
type.target.symbol && symbolToString(type.target.symbol)
|
|
);
|
|
}
|
|
}
|
|
return type.resolvedTypeArguments;
|
|
}
|
|
function getTypeReferenceArity(type) {
|
|
return length(type.target.typeParameters);
|
|
}
|
|
function getTypeFromClassOrInterfaceReference(node, symbol) {
|
|
const type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
|
|
const typeParameters = type.localTypeParameters;
|
|
if (typeParameters) {
|
|
const numTypeArguments = length(node.typeArguments);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
|
|
const isJs = isInJSFile(node);
|
|
const isJsImplicitAny = !noImplicitAny && isJs;
|
|
if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
|
|
const missingAugmentsTag = isJs && isExpressionWithTypeArguments(node) && !isJSDocAugmentsTag(node.parent);
|
|
const diag2 = minTypeArgumentCount === typeParameters.length ? missingAugmentsTag ? Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag : Diagnostics.Generic_type_0_requires_1_type_argument_s : missingAugmentsTag ? Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
|
|
const typeStr = typeToString(type, void 0, 2 /* WriteArrayAsGenericType */);
|
|
error(node, diag2, typeStr, minTypeArgumentCount, typeParameters.length);
|
|
if (!isJs) {
|
|
return errorType;
|
|
}
|
|
}
|
|
if (node.kind === 180 /* TypeReference */ && isDeferredTypeReferenceNode(node, length(node.typeArguments) !== typeParameters.length)) {
|
|
return createDeferredTypeReference(type, node, void 0);
|
|
}
|
|
const typeArguments = 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) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
|
|
return getStringMappingType(symbol, typeArguments[0]);
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
const typeParameters = links.typeParameters;
|
|
const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let instantiation = links.instantiations.get(id);
|
|
if (!instantiation) {
|
|
links.instantiations.set(id, instantiation = instantiateTypeWithAlias(
|
|
type,
|
|
createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(symbol.valueDeclaration))),
|
|
aliasSymbol,
|
|
aliasTypeArguments
|
|
));
|
|
}
|
|
return instantiation;
|
|
}
|
|
function getTypeFromTypeAliasReference(node, symbol) {
|
|
if (getCheckFlags(symbol) & 1048576 /* Unresolved */) {
|
|
const typeArguments = typeArgumentsFromTypeReferenceNode(node);
|
|
const id = getAliasId(symbol, typeArguments);
|
|
let errorType2 = errorTypes.get(id);
|
|
if (!errorType2) {
|
|
errorType2 = createIntrinsicType(1 /* Any */, "error");
|
|
errorType2.aliasSymbol = symbol;
|
|
errorType2.aliasTypeArguments = typeArguments;
|
|
errorTypes.set(id, errorType2);
|
|
}
|
|
return errorType2;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeParameters = getSymbolLinks(symbol).typeParameters;
|
|
if (typeParameters) {
|
|
const numTypeArguments = length(node.typeArguments);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
|
|
if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
|
|
error(
|
|
node,
|
|
minTypeArgumentCount === typeParameters.length ? Diagnostics.Generic_type_0_requires_1_type_argument_s : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments,
|
|
symbolToString(symbol),
|
|
minTypeArgumentCount,
|
|
typeParameters.length
|
|
);
|
|
return errorType;
|
|
}
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
let newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : void 0;
|
|
let aliasTypeArguments;
|
|
if (newAliasSymbol) {
|
|
aliasTypeArguments = getTypeArgumentsForAliasSymbol(newAliasSymbol);
|
|
} else if (isTypeReferenceType(node)) {
|
|
const aliasSymbol2 = resolveTypeReferenceName(node, 2097152 /* Alias */, true);
|
|
if (aliasSymbol2 && aliasSymbol2 !== unknownSymbol) {
|
|
const resolved = resolveAlias(aliasSymbol2);
|
|
if (resolved && resolved.flags & 524288 /* TypeAlias */) {
|
|
newAliasSymbol = resolved;
|
|
aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
|
|
}
|
|
}
|
|
}
|
|
return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, aliasTypeArguments);
|
|
}
|
|
return checkNoTypeArguments(node, symbol) ? type : errorType;
|
|
}
|
|
function isLocalTypeAlias(symbol) {
|
|
var _a2;
|
|
const declaration = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isTypeAlias);
|
|
return !!(declaration && getContainingFunction(declaration));
|
|
}
|
|
function getTypeReferenceName(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
const expr = node.expression;
|
|
if (isEntityNameExpression(expr)) {
|
|
return expr;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSymbolPath(symbol) {
|
|
return symbol.parent ? `${getSymbolPath(symbol.parent)}.${symbol.escapedName}` : symbol.escapedName;
|
|
}
|
|
function getUnresolvedSymbolForEntityName(name) {
|
|
const identifier = name.kind === 163 /* QualifiedName */ ? name.right : name.kind === 208 /* PropertyAccessExpression */ ? name.name : name;
|
|
const text = identifier.escapedText;
|
|
if (text) {
|
|
const parentSymbol = name.kind === 163 /* QualifiedName */ ? getUnresolvedSymbolForEntityName(name.left) : name.kind === 208 /* PropertyAccessExpression */ ? getUnresolvedSymbolForEntityName(name.expression) : void 0;
|
|
const path = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
|
|
let result = unresolvedSymbols.get(path);
|
|
if (!result) {
|
|
unresolvedSymbols.set(path, result = createSymbol(524288 /* TypeAlias */, text, 1048576 /* Unresolved */));
|
|
result.parent = parentSymbol;
|
|
result.declaredType = unresolvedType;
|
|
}
|
|
return result;
|
|
}
|
|
return unknownSymbol;
|
|
}
|
|
function resolveTypeReferenceName(typeReference, meaning, ignoreErrors) {
|
|
const name = getTypeReferenceName(typeReference);
|
|
if (!name) {
|
|
return unknownSymbol;
|
|
}
|
|
const 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 /* Class */ | 64 /* Interface */)) {
|
|
return getTypeFromClassOrInterfaceReference(node, symbol);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
return getTypeFromTypeAliasReference(node, symbol);
|
|
}
|
|
const res = tryGetDeclaredTypeOfSymbol(symbol);
|
|
if (res) {
|
|
return checkNoTypeArguments(node, symbol) ? getRegularTypeOfLiteralType(res) : errorType;
|
|
}
|
|
if (symbol.flags & 111551 /* Value */ && isJSDocTypeReference(node)) {
|
|
const jsdocType = getTypeFromJSDocValueReference(node, symbol);
|
|
if (jsdocType) {
|
|
return jsdocType;
|
|
} else {
|
|
resolveTypeReferenceName(node, 788968 /* Type */);
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
return errorType;
|
|
}
|
|
function getTypeFromJSDocValueReference(node, symbol) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedJSDocType) {
|
|
const valueType = getTypeOfSymbol(symbol);
|
|
let typeType = valueType;
|
|
if (symbol.valueDeclaration) {
|
|
const isImportTypeWithQualifier = node.kind === 202 /* ImportType */ && node.qualifier;
|
|
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 /* AnyOrUnknown */ || constraint === baseType || !isGenericType(baseType) && !isGenericType(constraint)) {
|
|
return baseType;
|
|
}
|
|
const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
|
|
const cached = substitutionTypes.get(id);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
const result = createType(33554432 /* 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 /* 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) : void 0;
|
|
}
|
|
function getConditionalFlowTypeOfType(type, node) {
|
|
let constraints;
|
|
let covariant = true;
|
|
while (node && !isStatement(node) && node.kind !== 323 /* JSDoc */) {
|
|
const parent = node.parent;
|
|
if (parent.kind === 166 /* Parameter */) {
|
|
covariant = !covariant;
|
|
}
|
|
if ((covariant || type.flags & 8650752 /* TypeVariable */) && parent.kind === 191 /* ConditionalType */ && node === parent.trueType) {
|
|
const constraint = getImpliedConstraint(type, parent.checkType, parent.extendsType);
|
|
if (constraint) {
|
|
constraints = append(constraints, constraint);
|
|
}
|
|
} else if (type.flags & 262144 /* TypeParameter */ && parent.kind === 197 /* MappedType */ && node === parent.type) {
|
|
const mappedType = getTypeFromTypeNode(parent);
|
|
if (getTypeParameterFromMappedType(mappedType) === getActualTypeVariable(type)) {
|
|
const typeParameter = getHomomorphicTypeVariable(mappedType);
|
|
if (typeParameter) {
|
|
const constraint = getConstraintOfTypeParameter(typeParameter);
|
|
if (constraint && everyType(constraint, isArrayOrTupleType)) {
|
|
constraints = append(constraints, getUnionType([numberType, numericStringType]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
node = parent;
|
|
}
|
|
return constraints ? getSubstitutionType(type, getIntersectionType(constraints)) : type;
|
|
}
|
|
function isJSDocTypeReference(node) {
|
|
return !!(node.flags & 8388608 /* JSDoc */) && (node.kind === 180 /* TypeReference */ || node.kind === 202 /* ImportType */);
|
|
}
|
|
function checkNoTypeArguments(node, symbol) {
|
|
if (node.typeArguments) {
|
|
error(node, Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? declarationNameToString(node.typeName) : anon);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getIntendedTypeFromJSDocTypeReference(node) {
|
|
if (isIdentifier(node.typeName)) {
|
|
const 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 : void 0;
|
|
case "promise":
|
|
return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : void 0;
|
|
case "Object":
|
|
if (typeArgs && typeArgs.length === 2) {
|
|
if (isJSDocIndexSignature(node)) {
|
|
const indexed = getTypeFromTypeNode(typeArgs[0]);
|
|
const target = getTypeFromTypeNode(typeArgs[1]);
|
|
const indexInfo = indexed === stringType || indexed === numberType ? [createIndexInfo(indexed, target, false)] : emptyArray;
|
|
return createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, indexInfo);
|
|
}
|
|
return anyType;
|
|
}
|
|
checkNoTypeArguments(node);
|
|
return !noImplicitAny ? anyType : void 0;
|
|
}
|
|
}
|
|
}
|
|
function getTypeFromJSDocNullableTypeNode(node) {
|
|
const type = getTypeFromTypeNode(node.type);
|
|
return strictNullChecks ? getNullableType(type, 65536 /* Null */) : type;
|
|
}
|
|
function getTypeFromTypeReference(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
if (isConstTypeReference(node) && isAssertionExpression(node.parent)) {
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = checkExpressionCached(node.parent.expression);
|
|
}
|
|
let symbol;
|
|
let type;
|
|
const meaning = 788968 /* Type */;
|
|
if (isJSDocTypeReference(node)) {
|
|
type = getIntendedTypeFromJSDocTypeReference(node);
|
|
if (!type) {
|
|
symbol = resolveTypeReferenceName(node, meaning, true);
|
|
if (symbol === unknownSymbol) {
|
|
symbol = resolveTypeReferenceName(node, meaning | 111551 /* Value */);
|
|
} else {
|
|
resolveTypeReferenceName(node, meaning);
|
|
}
|
|
type = getTypeReferenceType(node, symbol);
|
|
}
|
|
}
|
|
if (!type) {
|
|
symbol = resolveTypeReferenceName(node, meaning);
|
|
type = getTypeReferenceType(node, symbol);
|
|
}
|
|
links.resolvedSymbol = symbol;
|
|
links.resolvedType = type;
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function typeArgumentsFromTypeReferenceNode(node) {
|
|
return map(node.typeArguments, getTypeFromTypeNode);
|
|
}
|
|
function getTypeFromTypeQueryNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const type = checkExpressionWithTypeArguments(node);
|
|
links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeOfGlobalSymbol(symbol, arity) {
|
|
function getTypeDeclaration(symbol2) {
|
|
const declarations = symbol2.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
switch (declaration.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!symbol) {
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (!(type.flags & 524288 /* Object */)) {
|
|
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbolName(symbol));
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
if (length(type.typeParameters) !== arity) {
|
|
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbolName(symbol), arity);
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
return type;
|
|
}
|
|
function getGlobalValueSymbol(name, reportErrors2) {
|
|
return getGlobalSymbol(name, 111551 /* Value */, reportErrors2 ? Diagnostics.Cannot_find_global_value_0 : void 0);
|
|
}
|
|
function getGlobalTypeSymbol(name, reportErrors2) {
|
|
return getGlobalSymbol(name, 788968 /* Type */, reportErrors2 ? Diagnostics.Cannot_find_global_type_0 : void 0);
|
|
}
|
|
function getGlobalTypeAliasSymbol(name, arity, reportErrors2) {
|
|
const symbol = getGlobalSymbol(name, 788968 /* Type */, reportErrors2 ? Diagnostics.Cannot_find_global_type_0 : void 0);
|
|
if (symbol) {
|
|
getDeclaredTypeOfSymbol(symbol);
|
|
if (length(getSymbolLinks(symbol).typeParameters) !== arity) {
|
|
const decl = symbol.declarations && find(symbol.declarations, isTypeAliasDeclaration);
|
|
error(decl, Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbolName(symbol), arity);
|
|
return void 0;
|
|
}
|
|
}
|
|
return symbol;
|
|
}
|
|
function getGlobalSymbol(name, meaning, diagnostic) {
|
|
return resolveName(void 0, name, meaning, diagnostic, name, false, false, false);
|
|
}
|
|
function getGlobalType(name, arity, reportErrors2) {
|
|
const symbol = getGlobalTypeSymbol(name, reportErrors2);
|
|
return symbol || reportErrors2 ? getTypeOfGlobalSymbol(symbol, arity) : void 0;
|
|
}
|
|
function getGlobalTypedPropertyDescriptorType() {
|
|
return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType("TypedPropertyDescriptor", 1, true) || emptyGenericType);
|
|
}
|
|
function getGlobalTemplateStringsArrayType() {
|
|
return deferredGlobalTemplateStringsArrayType || (deferredGlobalTemplateStringsArrayType = getGlobalType("TemplateStringsArray", 0, true) || emptyObjectType);
|
|
}
|
|
function getGlobalImportMetaType() {
|
|
return deferredGlobalImportMetaType || (deferredGlobalImportMetaType = getGlobalType("ImportMeta", 0, true) || emptyObjectType);
|
|
}
|
|
function getGlobalImportMetaExpressionType() {
|
|
if (!deferredGlobalImportMetaExpressionType) {
|
|
const symbol = createSymbol(0 /* None */, "ImportMetaExpression");
|
|
const importMetaType = getGlobalImportMetaType();
|
|
const metaPropertySymbol = createSymbol(4 /* Property */, "meta", 8 /* Readonly */);
|
|
metaPropertySymbol.parent = symbol;
|
|
metaPropertySymbol.type = importMetaType;
|
|
const members = createSymbolTable([metaPropertySymbol]);
|
|
symbol.members = members;
|
|
deferredGlobalImportMetaExpressionType = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
return deferredGlobalImportMetaExpressionType;
|
|
}
|
|
function getGlobalImportCallOptionsType(reportErrors2) {
|
|
return deferredGlobalImportCallOptionsType || (deferredGlobalImportCallOptionsType = getGlobalType("ImportCallOptions", 0, reportErrors2)) || emptyObjectType;
|
|
}
|
|
function getGlobalESSymbolConstructorSymbol(reportErrors2) {
|
|
return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors2));
|
|
}
|
|
function getGlobalESSymbolConstructorTypeSymbol(reportErrors2) {
|
|
return deferredGlobalESSymbolConstructorTypeSymbol || (deferredGlobalESSymbolConstructorTypeSymbol = getGlobalTypeSymbol("SymbolConstructor", reportErrors2));
|
|
}
|
|
function getGlobalESSymbolType() {
|
|
return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", 0, false)) || emptyObjectType;
|
|
}
|
|
function getGlobalPromiseType(reportErrors2) {
|
|
return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalPromiseLikeType(reportErrors2) {
|
|
return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalPromiseConstructorSymbol(reportErrors2) {
|
|
return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors2));
|
|
}
|
|
function getGlobalPromiseConstructorLikeType(reportErrors2) {
|
|
return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", 0, reportErrors2)) || emptyObjectType;
|
|
}
|
|
function getGlobalAsyncIterableType(reportErrors2) {
|
|
return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncIteratorType(reportErrors2) {
|
|
return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncIterableIteratorType(reportErrors2) {
|
|
return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncGeneratorType(reportErrors2) {
|
|
return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIterableType(reportErrors2) {
|
|
return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorType(reportErrors2) {
|
|
return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIterableIteratorType(reportErrors2) {
|
|
return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalGeneratorType(reportErrors2) {
|
|
return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorYieldResultType(reportErrors2) {
|
|
return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorReturnResultType(reportErrors2) {
|
|
return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalTypeOrUndefined(name, arity = 0) {
|
|
const symbol = getGlobalSymbol(name, 788968 /* Type */, void 0);
|
|
return symbol && getTypeOfGlobalSymbol(symbol, arity);
|
|
}
|
|
function getGlobalExtractSymbol() {
|
|
deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalTypeAliasSymbol("Extract", 2, true) || unknownSymbol);
|
|
return deferredGlobalExtractSymbol === unknownSymbol ? void 0 : deferredGlobalExtractSymbol;
|
|
}
|
|
function getGlobalOmitSymbol() {
|
|
deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalTypeAliasSymbol("Omit", 2, true) || unknownSymbol);
|
|
return deferredGlobalOmitSymbol === unknownSymbol ? void 0 : deferredGlobalOmitSymbol;
|
|
}
|
|
function getGlobalAwaitedSymbol(reportErrors2) {
|
|
deferredGlobalAwaitedSymbol || (deferredGlobalAwaitedSymbol = getGlobalTypeAliasSymbol("Awaited", 1, reportErrors2) || (reportErrors2 ? unknownSymbol : void 0));
|
|
return deferredGlobalAwaitedSymbol === unknownSymbol ? void 0 : deferredGlobalAwaitedSymbol;
|
|
}
|
|
function getGlobalBigIntType() {
|
|
return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", 0, false)) || emptyObjectType;
|
|
}
|
|
function getGlobalNaNSymbol() {
|
|
return deferredGlobalNaNSymbol || (deferredGlobalNaNSymbol = getGlobalValueSymbol("NaN", false));
|
|
}
|
|
function getGlobalRecordSymbol() {
|
|
deferredGlobalRecordSymbol || (deferredGlobalRecordSymbol = getGlobalTypeAliasSymbol("Record", 2, true) || unknownSymbol);
|
|
return deferredGlobalRecordSymbol === unknownSymbol ? void 0 : deferredGlobalRecordSymbol;
|
|
}
|
|
function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
|
|
return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
|
|
}
|
|
function createTypedPropertyDescriptorType(propertyType) {
|
|
return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]);
|
|
}
|
|
function createIterableType(iteratedType) {
|
|
return createTypeFromGenericGlobalType(getGlobalIterableType(true), [iteratedType]);
|
|
}
|
|
function createArrayType(elementType, readonly) {
|
|
return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]);
|
|
}
|
|
function getTupleElementFlags(node) {
|
|
switch (node.kind) {
|
|
case 187 /* OptionalType */:
|
|
return 2 /* Optional */;
|
|
case 188 /* RestType */:
|
|
return getRestTypeElementFlags(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return node.questionToken ? 2 /* Optional */ : node.dotDotDotToken ? getRestTypeElementFlags(node) : 1 /* Required */;
|
|
default:
|
|
return 1 /* Required */;
|
|
}
|
|
}
|
|
function getRestTypeElementFlags(node) {
|
|
return getArrayElementTypeNode(node.type) ? 4 /* Rest */ : 8 /* Variadic */;
|
|
}
|
|
function getArrayOrTupleTargetType(node) {
|
|
const readonly = isReadonlyTypeOperator(node.parent);
|
|
const elementType = getArrayElementTypeNode(node);
|
|
if (elementType) {
|
|
return readonly ? globalReadonlyArrayType : globalArrayType;
|
|
}
|
|
const elementFlags = map(node.elements, getTupleElementFlags);
|
|
const missingName = some(node.elements, (e) => e.kind !== 199 /* NamedTupleMember */);
|
|
return getTupleTargetType(elementFlags, readonly, missingName ? void 0 : node.elements);
|
|
}
|
|
function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
|
|
return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 185 /* ArrayType */ ? mayResolveTypeAlias(node.elementType) : node.kind === 186 /* TupleType */ ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias));
|
|
}
|
|
function isResolvedByTypeAlias(node) {
|
|
const parent = node.parent;
|
|
switch (parent.kind) {
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
case 180 /* TypeReference */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 191 /* ConditionalType */:
|
|
case 195 /* TypeOperator */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return isResolvedByTypeAlias(parent);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function mayResolveTypeAlias(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node, 788968 /* Type */).flags & 524288 /* TypeAlias */);
|
|
case 183 /* TypeQuery */:
|
|
return true;
|
|
case 195 /* TypeOperator */:
|
|
return node.operator !== 156 /* UniqueKeyword */ && mayResolveTypeAlias(node.type);
|
|
case 193 /* ParenthesizedType */:
|
|
case 187 /* OptionalType */:
|
|
case 199 /* NamedTupleMember */:
|
|
case 319 /* JSDocOptionalType */:
|
|
case 317 /* JSDocNullableType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 312 /* JSDocTypeExpression */:
|
|
return mayResolveTypeAlias(node.type);
|
|
case 188 /* RestType */:
|
|
return node.type.kind !== 185 /* ArrayType */ || mayResolveTypeAlias(node.type.elementType);
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return some(node.types, mayResolveTypeAlias);
|
|
case 196 /* IndexedAccessType */:
|
|
return mayResolveTypeAlias(node.objectType) || mayResolveTypeAlias(node.indexType);
|
|
case 191 /* ConditionalType */:
|
|
return mayResolveTypeAlias(node.checkType) || mayResolveTypeAlias(node.extendsType) || mayResolveTypeAlias(node.trueType) || mayResolveTypeAlias(node.falseType);
|
|
}
|
|
return false;
|
|
}
|
|
function getTypeFromArrayOrTupleTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const target = getArrayOrTupleTargetType(node);
|
|
if (target === emptyGenericType) {
|
|
links.resolvedType = emptyObjectType;
|
|
} else if (!(node.kind === 186 /* TupleType */ && some(node.elements, (e) => !!(getTupleElementFlags(e) & 8 /* Variadic */))) && isDeferredTypeReferenceNode(node)) {
|
|
links.resolvedType = node.kind === 186 /* TupleType */ && node.elements.length === 0 ? target : createDeferredTypeReference(target, node, void 0);
|
|
} else {
|
|
const elementTypes = node.kind === 185 /* ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode);
|
|
links.resolvedType = createNormalizedTypeReference(target, elementTypes);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isReadonlyTypeOperator(node) {
|
|
return isTypeOperatorNode(node) && node.operator === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function createTupleType(elementTypes, elementFlags, readonly = false, namedMemberDeclarations) {
|
|
const tupleTarget = getTupleTargetType(elementFlags || map(elementTypes, (_) => 1 /* 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 /* Rest */) {
|
|
return readonly ? globalReadonlyArrayType : globalArrayType;
|
|
}
|
|
const key = map(elementFlags, (f) => f & 1 /* Required */ ? "#" : f & 2 /* Optional */ ? "?" : f & 4 /* Rest */ ? "." : "*").join() + (readonly ? "R" : "") + (namedMemberDeclarations && namedMemberDeclarations.length ? "," + map(namedMemberDeclarations, getNodeId).join(",") : "");
|
|
let type = tupleTypes.get(key);
|
|
if (!type) {
|
|
tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations));
|
|
}
|
|
return type;
|
|
}
|
|
function createTupleTargetType(elementFlags, readonly, namedMemberDeclarations) {
|
|
const arity = elementFlags.length;
|
|
const minLength = countWhere(elementFlags, (f) => !!(f & (1 /* Required */ | 8 /* Variadic */)));
|
|
let typeParameters;
|
|
const properties = [];
|
|
let combinedFlags = 0;
|
|
if (arity) {
|
|
typeParameters = new Array(arity);
|
|
for (let i = 0; i < arity; i++) {
|
|
const typeParameter = typeParameters[i] = createTypeParameter();
|
|
const flags = elementFlags[i];
|
|
combinedFlags |= flags;
|
|
if (!(combinedFlags & 12 /* Variable */)) {
|
|
const property = createSymbol(
|
|
4 /* Property */ | (flags & 2 /* Optional */ ? 16777216 /* Optional */ : 0),
|
|
"" + i,
|
|
readonly ? 8 /* Readonly */ : 0
|
|
);
|
|
property.tupleLabelDeclaration = namedMemberDeclarations == null ? void 0 : namedMemberDeclarations[i];
|
|
property.type = typeParameter;
|
|
properties.push(property);
|
|
}
|
|
}
|
|
}
|
|
const fixedLength = properties.length;
|
|
const lengthSymbol = createSymbol(4 /* Property */, "length", readonly ? 8 /* Readonly */ : 0);
|
|
if (combinedFlags & 12 /* Variable */) {
|
|
lengthSymbol.type = numberType;
|
|
} else {
|
|
const literalTypes = [];
|
|
for (let i = minLength; i <= arity; i++)
|
|
literalTypes.push(getNumberLiteralType(i));
|
|
lengthSymbol.type = getUnionType(literalTypes);
|
|
}
|
|
properties.push(lengthSymbol);
|
|
const type = createObjectType(8 /* Tuple */ | 4 /* Reference */);
|
|
type.typeParameters = typeParameters;
|
|
type.outerTypeParameters = void 0;
|
|
type.localTypeParameters = typeParameters;
|
|
type.instantiations = /* @__PURE__ */ new 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 = emptyArray;
|
|
type.declaredConstructSignatures = emptyArray;
|
|
type.declaredIndexInfos = emptyArray;
|
|
type.elementFlags = elementFlags;
|
|
type.minLength = minLength;
|
|
type.fixedLength = fixedLength;
|
|
type.hasRestElement = !!(combinedFlags & 12 /* Variable */);
|
|
type.combinedFlags = combinedFlags;
|
|
type.readonly = readonly;
|
|
type.labeledElementDeclarations = namedMemberDeclarations;
|
|
return type;
|
|
}
|
|
function createNormalizedTypeReference(target, typeArguments) {
|
|
return target.objectFlags & 8 /* Tuple */ ? createNormalizedTupleType(target, typeArguments) : createTypeReference(target, typeArguments);
|
|
}
|
|
function createNormalizedTupleType(target, elementTypes) {
|
|
var _a2, _b, _c;
|
|
if (!(target.combinedFlags & 14 /* NonRequired */)) {
|
|
return createTypeReference(target, elementTypes);
|
|
}
|
|
if (target.combinedFlags & 8 /* Variadic */) {
|
|
const unionIndex = findIndex(elementTypes, (t, i) => !!(target.elementFlags[i] & 8 /* Variadic */ && t.flags & (131072 /* Never */ | 1048576 /* Union */)));
|
|
if (unionIndex >= 0) {
|
|
return checkCrossProductUnion(map(elementTypes, (t, i) => target.elementFlags[i] & 8 /* Variadic */ ? t : unknownType)) ? mapType(elementTypes[unionIndex], (t) => createNormalizedTupleType(target, replaceElement(elementTypes, unionIndex, t))) : errorType;
|
|
}
|
|
}
|
|
const expandedTypes = [];
|
|
const expandedFlags = [];
|
|
let expandedDeclarations = [];
|
|
let lastRequiredIndex = -1;
|
|
let firstRestIndex = -1;
|
|
let lastOptionalOrRestIndex = -1;
|
|
for (let i = 0; i < elementTypes.length; i++) {
|
|
const type = elementTypes[i];
|
|
const flags = target.elementFlags[i];
|
|
if (flags & 8 /* Variadic */) {
|
|
if (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type)) {
|
|
addElement(type, 8 /* Variadic */, (_a2 = target.labeledElementDeclarations) == null ? void 0 : _a2[i]);
|
|
} else if (isTupleType(type)) {
|
|
const elements = getTypeArguments(type);
|
|
if (elements.length + expandedTypes.length >= 1e4) {
|
|
error(currentNode, isPartOfTypeNode(currentNode) ? Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent : Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent);
|
|
return errorType;
|
|
}
|
|
forEach(elements, (t, n) => {
|
|
var _a3;
|
|
return addElement(t, type.target.elementFlags[n], (_a3 = type.target.labeledElementDeclarations) == null ? void 0 : _a3[n]);
|
|
});
|
|
} else {
|
|
addElement(isArrayLikeType(type) && getIndexTypeOfType(type, numberType) || errorType, 4 /* Rest */, (_b = target.labeledElementDeclarations) == null ? void 0 : _b[i]);
|
|
}
|
|
} else {
|
|
addElement(type, flags, (_c = target.labeledElementDeclarations) == null ? void 0 : _c[i]);
|
|
}
|
|
}
|
|
for (let i = 0; i < lastRequiredIndex; i++) {
|
|
if (expandedFlags[i] & 2 /* Optional */)
|
|
expandedFlags[i] = 1 /* Required */;
|
|
}
|
|
if (firstRestIndex >= 0 && firstRestIndex < lastOptionalOrRestIndex) {
|
|
expandedTypes[firstRestIndex] = getUnionType(sameMap(
|
|
expandedTypes.slice(firstRestIndex, lastOptionalOrRestIndex + 1),
|
|
(t, i) => expandedFlags[firstRestIndex + i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t
|
|
));
|
|
expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
expandedDeclarations == null ? void 0 : expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
}
|
|
const tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations);
|
|
return tupleTarget === emptyGenericType ? emptyObjectType : expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) : tupleTarget;
|
|
function addElement(type, flags, declaration) {
|
|
if (flags & 1 /* Required */) {
|
|
lastRequiredIndex = expandedFlags.length;
|
|
}
|
|
if (flags & 4 /* Rest */ && firstRestIndex < 0) {
|
|
firstRestIndex = expandedFlags.length;
|
|
}
|
|
if (flags & (2 /* Optional */ | 4 /* Rest */)) {
|
|
lastOptionalOrRestIndex = expandedFlags.length;
|
|
}
|
|
expandedTypes.push(flags & 2 /* Optional */ ? addOptionality(type, true) : type);
|
|
expandedFlags.push(flags);
|
|
if (expandedDeclarations && declaration) {
|
|
expandedDeclarations.push(declaration);
|
|
} else {
|
|
expandedDeclarations = void 0;
|
|
}
|
|
}
|
|
}
|
|
function sliceTupleType(type, index, endSkipCount = 0) {
|
|
const target = type.target;
|
|
const endIndex = getTypeReferenceArity(type) - endSkipCount;
|
|
return index > target.fixedLength ? getRestArrayTypeOfTupleType(type) || createTupleType(emptyArray) : createTupleType(
|
|
getTypeArguments(type).slice(index, endIndex),
|
|
target.elementFlags.slice(index, endIndex),
|
|
false,
|
|
target.labeledElementDeclarations && target.labeledElementDeclarations.slice(index, endIndex)
|
|
);
|
|
}
|
|
function getKnownKeysOfTupleType(type) {
|
|
return getUnionType(append(
|
|
arrayOf(type.target.fixedLength, (i) => getStringLiteralType("" + i)),
|
|
getIndexType(type.target.readonly ? globalReadonlyArrayType : globalArrayType)
|
|
));
|
|
}
|
|
function getStartElementCount(type, flags) {
|
|
const index = findIndex(type.elementFlags, (f) => !(f & flags));
|
|
return index >= 0 ? index : type.elementFlags.length;
|
|
}
|
|
function getEndElementCount(type, flags) {
|
|
return type.elementFlags.length - findLastIndex(type.elementFlags, (f) => !(f & flags)) - 1;
|
|
}
|
|
function getTypeFromOptionalTypeNode(node) {
|
|
return addOptionality(getTypeFromTypeNode(node.type), true);
|
|
}
|
|
function getTypeId(type) {
|
|
return type.id;
|
|
}
|
|
function containsType(types, type) {
|
|
return binarySearch(types, type, getTypeId, compareValues) >= 0;
|
|
}
|
|
function insertType(types, type) {
|
|
const index = binarySearch(types, type, getTypeId, compareValues);
|
|
if (index < 0) {
|
|
types.splice(~index, 0, type);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function addTypeToUnion(typeSet, includes, type) {
|
|
const flags = type.flags;
|
|
if (flags & 1048576 /* Union */) {
|
|
return addTypesToUnion(typeSet, includes | (isNamedUnionType(type) ? 1048576 /* Union */ : 0), type.types);
|
|
}
|
|
if (!(flags & 131072 /* Never */)) {
|
|
includes |= flags & 205258751 /* IncludesMask */;
|
|
if (flags & 465829888 /* Instantiable */)
|
|
includes |= 33554432 /* IncludesInstantiable */;
|
|
if (type === wildcardType)
|
|
includes |= 8388608 /* IncludesWildcard */;
|
|
if (!strictNullChecks && flags & 98304 /* Nullable */) {
|
|
if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */))
|
|
includes |= 4194304 /* IncludesNonWideningType */;
|
|
} else {
|
|
const len = typeSet.length;
|
|
const index = len && type.id > typeSet[len - 1].id ? ~len : binarySearch(typeSet, type, getTypeId, compareValues);
|
|
if (index < 0) {
|
|
typeSet.splice(~index, 0, type);
|
|
}
|
|
}
|
|
}
|
|
return includes;
|
|
}
|
|
function addTypesToUnion(typeSet, includes, types) {
|
|
for (const type of types) {
|
|
includes = addTypeToUnion(typeSet, includes, type);
|
|
}
|
|
return includes;
|
|
}
|
|
function removeSubtypes(types, hasObjectTypes) {
|
|
var _a2;
|
|
if (types.length < 2) {
|
|
return types;
|
|
}
|
|
const id = getTypeListId(types);
|
|
const match = subtypeReductionCache.get(id);
|
|
if (match) {
|
|
return match;
|
|
}
|
|
const hasEmptyObject = hasObjectTypes && some(types, (t) => !!(t.flags & 524288 /* Object */) && !isGenericMappedType(t) && isEmptyResolvedType(resolveStructuredTypeMembers(t)));
|
|
const len = types.length;
|
|
let i = len;
|
|
let count = 0;
|
|
while (i > 0) {
|
|
i--;
|
|
const source = types[i];
|
|
if (hasEmptyObject || source.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
const keyProperty = source.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */) ? find(getPropertiesOfType(source), (p) => isUnitType(getTypeOfSymbol(p))) : void 0;
|
|
const keyPropertyType = keyProperty && getRegularTypeOfLiteralType(getTypeOfSymbol(keyProperty));
|
|
for (const target of types) {
|
|
if (source !== target) {
|
|
if (count === 1e5) {
|
|
const estimatedCount = count / (len - i) * len;
|
|
if (estimatedCount > 1e6) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "removeSubtypes_DepthLimit", { typeIds: types.map((t) => t.id) });
|
|
error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
|
|
return void 0;
|
|
}
|
|
}
|
|
count++;
|
|
if (keyProperty && target.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
const t = getTypeOfPropertyOfType(target, keyProperty.escapedName);
|
|
if (t && isUnitType(t) && getRegularTypeOfLiteralType(t) !== keyPropertyType) {
|
|
continue;
|
|
}
|
|
}
|
|
if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(getObjectFlags(getTargetType(source)) & 1 /* Class */) || !(getObjectFlags(getTargetType(target)) & 1 /* Class */) || isTypeDerivedFrom(source, target))) {
|
|
orderedRemoveItemAt(types, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
subtypeReductionCache.set(id, types);
|
|
return types;
|
|
}
|
|
function removeRedundantLiteralTypes(types, includes, reduceVoidUndefined) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
const flags = t.flags;
|
|
const remove = flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && includes & 4 /* String */ || flags & 256 /* NumberLiteral */ && includes & 8 /* Number */ || flags & 2048 /* BigIntLiteral */ && includes & 64 /* BigInt */ || flags & 8192 /* UniqueESSymbol */ && includes & 4096 /* ESSymbol */ || reduceVoidUndefined && flags & 32768 /* Undefined */ && includes & 16384 /* Void */ || isFreshLiteralType(t) && containsType(types, t.regularType);
|
|
if (remove) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
function removeStringLiteralsMatchedByTemplateLiterals(types) {
|
|
const templates = filter(types, isPatternLiteralType);
|
|
if (templates.length) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
if (t.flags & 128 /* StringLiteral */ && some(templates, (template) => isTypeMatchedByTemplateLiteralType(t, template))) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isNamedUnionType(type) {
|
|
return !!(type.flags & 1048576 /* Union */ && (type.aliasSymbol || type.origin));
|
|
}
|
|
function addNamedUnions(namedUnions, types) {
|
|
for (const t of types) {
|
|
if (t.flags & 1048576 /* Union */) {
|
|
const origin = t.origin;
|
|
if (t.aliasSymbol || origin && !(origin.flags & 1048576 /* Union */)) {
|
|
pushIfUnique(namedUnions, t);
|
|
} else if (origin && origin.flags & 1048576 /* Union */) {
|
|
addNamedUnions(namedUnions, origin.types);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createOriginUnionOrIntersectionType(flags, types) {
|
|
const result = createOriginType(flags);
|
|
result.types = types;
|
|
return result;
|
|
}
|
|
function getUnionType(types, unionReduction = 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin) {
|
|
if (types.length === 0) {
|
|
return neverType;
|
|
}
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
let typeSet = [];
|
|
const includes = addTypesToUnion(typeSet, 0, types);
|
|
if (unionReduction !== 0 /* None */) {
|
|
if (includes & 3 /* AnyOrUnknown */) {
|
|
return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType : includes & 65536 /* Null */ || containsType(typeSet, unknownType) ? unknownType : nonNullUnknownType;
|
|
}
|
|
if (exactOptionalPropertyTypes && includes & 32768 /* Undefined */) {
|
|
const missingIndex = binarySearch(typeSet, missingType, getTypeId, compareValues);
|
|
if (missingIndex >= 0 && containsType(typeSet, undefinedType)) {
|
|
orderedRemoveItemAt(typeSet, missingIndex);
|
|
}
|
|
}
|
|
if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) {
|
|
removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* Subtype */));
|
|
}
|
|
if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) {
|
|
removeStringLiteralsMatchedByTemplateLiterals(typeSet);
|
|
}
|
|
if (unionReduction === 2 /* Subtype */) {
|
|
typeSet = removeSubtypes(typeSet, !!(includes & 524288 /* Object */));
|
|
if (!typeSet) {
|
|
return errorType;
|
|
}
|
|
}
|
|
if (typeSet.length === 0) {
|
|
return includes & 65536 /* Null */ ? includes & 4194304 /* IncludesNonWideningType */ ? nullType : nullWideningType : includes & 32768 /* Undefined */ ? includes & 4194304 /* IncludesNonWideningType */ ? undefinedType : undefinedWideningType : neverType;
|
|
}
|
|
}
|
|
if (!origin && includes & 1048576 /* Union */) {
|
|
const namedUnions = [];
|
|
addNamedUnions(namedUnions, types);
|
|
const reducedTypes = [];
|
|
for (const t of typeSet) {
|
|
if (!some(namedUnions, (union) => containsType(union.types, t))) {
|
|
reducedTypes.push(t);
|
|
}
|
|
}
|
|
if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
|
|
return namedUnions[0];
|
|
}
|
|
const namedTypesCount = reduceLeft(namedUnions, (sum2, union) => sum2 + union.types.length, 0);
|
|
if (namedTypesCount + reducedTypes.length === typeSet.length) {
|
|
for (const t of namedUnions) {
|
|
insertType(reducedTypes, t);
|
|
}
|
|
origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
|
|
}
|
|
}
|
|
const objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
|
|
return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
|
|
}
|
|
function getUnionOrIntersectionTypePredicate(signatures, kind) {
|
|
let first2;
|
|
const types = [];
|
|
for (const sig of signatures) {
|
|
const pred = getTypePredicateOfSignature(sig);
|
|
if (!pred || pred.kind === 2 /* AssertsThis */ || pred.kind === 3 /* AssertsIdentifier */) {
|
|
if (kind !== 2097152 /* Intersection */) {
|
|
continue;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (first2) {
|
|
if (!typePredicateKindsMatch(first2, pred)) {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
first2 = pred;
|
|
}
|
|
types.push(pred.type);
|
|
}
|
|
if (!first2) {
|
|
return void 0;
|
|
}
|
|
const compositeType = getUnionOrIntersectionType(types, kind);
|
|
return createTypePredicate(first2.kind, first2.parameterName, first2.parameterIndex, compositeType);
|
|
}
|
|
function typePredicateKindsMatch(a, b) {
|
|
return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
|
|
}
|
|
function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) {
|
|
if (types.length === 0) {
|
|
return neverType;
|
|
}
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
const typeKey = !origin ? getTypeListId(types) : origin.flags & 1048576 /* Union */ ? `|${getTypeListId(origin.types)}` : origin.flags & 2097152 /* Intersection */ ? `&${getTypeListId(origin.types)}` : `#${origin.type.id}|${getTypeListId(types)}`;
|
|
const id = typeKey + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let type = unionTypes.get(id);
|
|
if (!type) {
|
|
type = createType(1048576 /* Union */);
|
|
type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, 98304 /* Nullable */);
|
|
type.types = types;
|
|
type.origin = origin;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
if (types.length === 2 && types[0].flags & 512 /* BooleanLiteral */ && types[1].flags & 512 /* BooleanLiteral */) {
|
|
type.flags |= 16 /* Boolean */;
|
|
type.intrinsicName = "boolean";
|
|
}
|
|
unionTypes.set(id, type);
|
|
}
|
|
return type;
|
|
}
|
|
function getTypeFromUnionTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
links.resolvedType = getUnionType(
|
|
map(node.types, getTypeFromTypeNode),
|
|
1 /* Literal */,
|
|
aliasSymbol,
|
|
getTypeArgumentsForAliasSymbol(aliasSymbol)
|
|
);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function addTypeToIntersection(typeSet, includes, type) {
|
|
const flags = type.flags;
|
|
if (flags & 2097152 /* Intersection */) {
|
|
return addTypesToIntersection(typeSet, includes, type.types);
|
|
}
|
|
if (isEmptyAnonymousObjectType(type)) {
|
|
if (!(includes & 16777216 /* IncludesEmptyObject */)) {
|
|
includes |= 16777216 /* IncludesEmptyObject */;
|
|
typeSet.set(type.id.toString(), type);
|
|
}
|
|
} else {
|
|
if (flags & 3 /* AnyOrUnknown */) {
|
|
if (type === wildcardType)
|
|
includes |= 8388608 /* IncludesWildcard */;
|
|
} else if (strictNullChecks || !(flags & 98304 /* Nullable */)) {
|
|
if (exactOptionalPropertyTypes && type === missingType) {
|
|
includes |= 262144 /* IncludesMissingType */;
|
|
type = undefinedType;
|
|
}
|
|
if (!typeSet.has(type.id.toString())) {
|
|
if (type.flags & 109440 /* Unit */ && includes & 109440 /* Unit */) {
|
|
includes |= 67108864 /* NonPrimitive */;
|
|
}
|
|
typeSet.set(type.id.toString(), type);
|
|
}
|
|
}
|
|
includes |= flags & 205258751 /* IncludesMask */;
|
|
}
|
|
return includes;
|
|
}
|
|
function addTypesToIntersection(typeSet, includes, types) {
|
|
for (const type of types) {
|
|
includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
|
|
}
|
|
return includes;
|
|
}
|
|
function removeRedundantSupertypes(types, includes) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
const remove = t.flags & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || t.flags & 8 /* Number */ && includes & 256 /* NumberLiteral */ || t.flags & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ || isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
|
|
if (remove) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
function eachUnionContains(unionTypes2, type) {
|
|
for (const u of unionTypes2) {
|
|
if (!containsType(u.types, type)) {
|
|
const primitive = type.flags & 128 /* StringLiteral */ ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : void 0;
|
|
if (!primitive || !containsType(u.types, primitive)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function extractRedundantTemplateLiterals(types) {
|
|
let i = types.length;
|
|
const literals = filter(types, (t) => !!(t.flags & 128 /* StringLiteral */));
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
if (!(t.flags & 134217728 /* TemplateLiteral */))
|
|
continue;
|
|
for (const t2 of literals) {
|
|
if (isTypeSubtypeOf(t2, t)) {
|
|
orderedRemoveItemAt(types, i);
|
|
break;
|
|
} else if (isPatternLiteralType(t)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function eachIsUnionContaining(types, flag) {
|
|
return every(types, (t) => !!(t.flags & 1048576 /* Union */) && some(t.types, (tt) => !!(tt.flags & flag)));
|
|
}
|
|
function removeFromEach(types, flag) {
|
|
for (let i = 0; i < types.length; i++) {
|
|
types[i] = filterType(types[i], (t) => !(t.flags & flag));
|
|
}
|
|
}
|
|
function intersectUnionsOfPrimitiveTypes(types) {
|
|
let unionTypes2;
|
|
const index = findIndex(types, (t) => !!(getObjectFlags(t) & 32768 /* PrimitiveUnion */));
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
let i = index + 1;
|
|
while (i < types.length) {
|
|
const t = types[i];
|
|
if (getObjectFlags(t) & 32768 /* PrimitiveUnion */) {
|
|
(unionTypes2 || (unionTypes2 = [types[index]])).push(t);
|
|
orderedRemoveItemAt(types, i);
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
if (!unionTypes2) {
|
|
return false;
|
|
}
|
|
const checked = [];
|
|
const result = [];
|
|
for (const u of unionTypes2) {
|
|
for (const t of u.types) {
|
|
if (insertType(checked, t)) {
|
|
if (eachUnionContains(unionTypes2, t)) {
|
|
insertType(result, t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
types[index] = getUnionTypeFromSortedList(result, 32768 /* PrimitiveUnion */);
|
|
return true;
|
|
}
|
|
function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
|
|
const result = createType(2097152 /* Intersection */);
|
|
result.objectFlags = getPropagatingFlagsOfTypes(types, 98304 /* Nullable */);
|
|
result.types = types;
|
|
result.aliasSymbol = aliasSymbol;
|
|
result.aliasTypeArguments = aliasTypeArguments;
|
|
return result;
|
|
}
|
|
function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
|
|
const typeMembershipMap = /* @__PURE__ */ new Map();
|
|
const includes = addTypesToIntersection(typeMembershipMap, 0, types);
|
|
const typeSet = arrayFrom(typeMembershipMap.values());
|
|
if (includes & 131072 /* Never */) {
|
|
return contains(typeSet, silentNeverType) ? silentNeverType : neverType;
|
|
}
|
|
if (strictNullChecks && includes & 98304 /* Nullable */ && includes & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 16777216 /* IncludesEmptyObject */) || includes & 67108864 /* NonPrimitive */ && includes & (469892092 /* DisjointDomains */ & ~67108864 /* NonPrimitive */) || includes & 402653316 /* StringLike */ && includes & (469892092 /* DisjointDomains */ & ~402653316 /* StringLike */) || includes & 296 /* NumberLike */ && includes & (469892092 /* DisjointDomains */ & ~296 /* NumberLike */) || includes & 2112 /* BigIntLike */ && includes & (469892092 /* DisjointDomains */ & ~2112 /* BigIntLike */) || includes & 12288 /* ESSymbolLike */ && includes & (469892092 /* DisjointDomains */ & ~12288 /* ESSymbolLike */) || includes & 49152 /* VoidLike */ && includes & (469892092 /* DisjointDomains */ & ~49152 /* VoidLike */)) {
|
|
return neverType;
|
|
}
|
|
if (includes & 134217728 /* TemplateLiteral */ && includes & 128 /* StringLiteral */ && extractRedundantTemplateLiterals(typeSet)) {
|
|
return neverType;
|
|
}
|
|
if (includes & 1 /* Any */) {
|
|
return includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType;
|
|
}
|
|
if (!strictNullChecks && includes & 98304 /* Nullable */) {
|
|
return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 32768 /* Undefined */ ? undefinedType : nullType;
|
|
}
|
|
if (includes & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 8 /* Number */ && includes & 256 /* NumberLiteral */ || includes & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || includes & 16384 /* Void */ && includes & 32768 /* Undefined */ || includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
|
|
if (!noSupertypeReduction)
|
|
removeRedundantSupertypes(typeSet, includes);
|
|
}
|
|
if (includes & 262144 /* IncludesMissingType */) {
|
|
typeSet[typeSet.indexOf(undefinedType)] = missingType;
|
|
}
|
|
if (typeSet.length === 0) {
|
|
return unknownType;
|
|
}
|
|
if (typeSet.length === 1) {
|
|
return typeSet[0];
|
|
}
|
|
const id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let result = intersectionTypes.get(id);
|
|
if (!result) {
|
|
if (includes & 1048576 /* Union */) {
|
|
if (intersectUnionsOfPrimitiveTypes(typeSet)) {
|
|
result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
|
|
} else if (eachIsUnionContaining(typeSet, 32768 /* Undefined */)) {
|
|
const undefinedOrMissingType = exactOptionalPropertyTypes && some(typeSet, (t) => containsType(t.types, missingType)) ? missingType : undefinedType;
|
|
removeFromEach(typeSet, 32768 /* Undefined */);
|
|
result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
} else if (eachIsUnionContaining(typeSet, 65536 /* Null */)) {
|
|
removeFromEach(typeSet, 65536 /* Null */);
|
|
result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
} else {
|
|
if (!checkCrossProductUnion(typeSet)) {
|
|
return errorType;
|
|
}
|
|
const constituents = getCrossProductIntersections(typeSet);
|
|
const origin = some(constituents, (t) => !!(t.flags & 2097152 /* Intersection */)) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : void 0;
|
|
result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
|
|
}
|
|
} else {
|
|
result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
intersectionTypes.set(id, result);
|
|
}
|
|
return result;
|
|
}
|
|
function getCrossProductUnionSize(types) {
|
|
return reduceLeft(types, (n, t) => t.flags & 1048576 /* Union */ ? n * t.types.length : t.flags & 131072 /* Never */ ? 0 : n, 1);
|
|
}
|
|
function checkCrossProductUnion(types) {
|
|
var _a2;
|
|
const size = getCrossProductUnionSize(types);
|
|
if (size >= 1e5) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "checkCrossProductUnion_DepthLimit", { typeIds: types.map((t) => t.id), size });
|
|
error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getCrossProductIntersections(types) {
|
|
const count = getCrossProductUnionSize(types);
|
|
const intersections = [];
|
|
for (let i = 0; i < count; i++) {
|
|
const constituents = types.slice();
|
|
let n = i;
|
|
for (let j = types.length - 1; j >= 0; j--) {
|
|
if (types[j].flags & 1048576 /* Union */) {
|
|
const sourceTypes = types[j].types;
|
|
const length2 = sourceTypes.length;
|
|
constituents[j] = sourceTypes[n % length2];
|
|
n = Math.floor(n / length2);
|
|
}
|
|
}
|
|
const t = getIntersectionType(constituents);
|
|
if (!(t.flags & 131072 /* Never */))
|
|
intersections.push(t);
|
|
}
|
|
return intersections;
|
|
}
|
|
function getConstituentCount(type) {
|
|
return !(type.flags & 3145728 /* UnionOrIntersection */) || type.aliasSymbol ? 1 : type.flags & 1048576 /* Union */ && type.origin ? getConstituentCount(type.origin) : getConstituentCountOfTypes(type.types);
|
|
}
|
|
function getConstituentCountOfTypes(types) {
|
|
return reduceLeft(types, (n, t) => n + getConstituentCount(t), 0);
|
|
}
|
|
function getTypeFromIntersectionTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
const types = map(node.types, getTypeFromTypeNode);
|
|
const noSupertypeReduction = types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType;
|
|
links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function createIndexType(type, stringsOnly) {
|
|
const result = createType(4194304 /* Index */);
|
|
result.type = type;
|
|
result.stringsOnly = stringsOnly;
|
|
return result;
|
|
}
|
|
function createOriginIndexType(type) {
|
|
const result = createOriginType(4194304 /* Index */);
|
|
result.type = type;
|
|
return result;
|
|
}
|
|
function getIndexTypeForGenericType(type, stringsOnly) {
|
|
return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, true)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, false));
|
|
}
|
|
function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
|
|
const typeParameter = getTypeParameterFromMappedType(type);
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
const nameType = getNameTypeFromMappedType(type.target || type);
|
|
if (!nameType && !noIndexSignatures) {
|
|
return constraintType;
|
|
}
|
|
const keyTypes = [];
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
if (!isGenericIndexType(constraintType)) {
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
|
|
} else {
|
|
return getIndexTypeForGenericType(type, stringsOnly);
|
|
}
|
|
} else {
|
|
forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
|
|
}
|
|
if (isGenericIndexType(constraintType)) {
|
|
forEachType(constraintType, addMemberForKeyType);
|
|
}
|
|
const result = noIndexSignatures ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
|
|
if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
|
|
return constraintType;
|
|
}
|
|
return result;
|
|
function addMemberForKeyType(keyType) {
|
|
const propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
|
|
keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType);
|
|
}
|
|
}
|
|
function hasDistributiveNameType(mappedType) {
|
|
const typeVariable = getTypeParameterFromMappedType(mappedType);
|
|
return isDistributive(getNameTypeFromMappedType(mappedType) || typeVariable);
|
|
function isDistributive(type) {
|
|
return type.flags & (3 /* AnyOrUnknown */ | 131068 /* Primitive */ | 131072 /* Never */ | 262144 /* TypeParameter */ | 524288 /* Object */ | 67108864 /* NonPrimitive */) ? true : type.flags & 16777216 /* Conditional */ ? type.root.isDistributive && type.checkType === typeVariable : type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) ? every(type.types, isDistributive) : type.flags & 8388608 /* IndexedAccess */ ? isDistributive(type.objectType) && isDistributive(type.indexType) : type.flags & 33554432 /* Substitution */ ? isDistributive(type.baseType) && isDistributive(type.constraint) : type.flags & 268435456 /* StringMapping */ ? isDistributive(type.type) : false;
|
|
}
|
|
}
|
|
function getLiteralTypeFromPropertyName(name) {
|
|
if (isPrivateIdentifier(name)) {
|
|
return neverType;
|
|
}
|
|
return isIdentifier(name) ? getStringLiteralType(unescapeLeadingUnderscores(name.escapedText)) : getRegularTypeOfLiteralType(isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name));
|
|
}
|
|
function getLiteralTypeFromProperty(prop, include, includeNonPublic) {
|
|
if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 24 /* NonPublicAccessibilityModifier */)) {
|
|
let type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
|
|
if (!type) {
|
|
const name = getNameOfDeclaration(prop.valueDeclaration);
|
|
type = prop.escapedName === "default" /* Default */ ? getStringLiteralType("default") : name && getLiteralTypeFromPropertyName(name) || (!isKnownSymbol(prop) ? getStringLiteralType(symbolName(prop)) : void 0);
|
|
}
|
|
if (type && type.flags & include) {
|
|
return type;
|
|
}
|
|
}
|
|
return neverType;
|
|
}
|
|
function isKeyTypeIncluded(keyType, include) {
|
|
return !!(keyType.flags & include || keyType.flags & 2097152 /* Intersection */ && some(keyType.types, (t) => isKeyTypeIncluded(t, include)));
|
|
}
|
|
function getLiteralTypeFromProperties(type, include, includeOrigin) {
|
|
const origin = includeOrigin && (getObjectFlags(type) & (3 /* ClassOrInterface */ | 4 /* Reference */) || type.aliasSymbol) ? createOriginIndexType(type) : void 0;
|
|
const propertyTypes = map(getPropertiesOfType(type), (prop) => getLiteralTypeFromProperty(prop, include));
|
|
const indexKeyTypes = map(getIndexInfosOfType(type), (info) => info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ? info.keyType === stringType && include & 8 /* Number */ ? stringOrNumberType : info.keyType : neverType);
|
|
return getUnionType(
|
|
concatenate(propertyTypes, indexKeyTypes),
|
|
1 /* Literal */,
|
|
void 0,
|
|
void 0,
|
|
origin
|
|
);
|
|
}
|
|
function isPossiblyReducibleByInstantiation(type) {
|
|
const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
|
|
return getReducedType(uniqueFilled) !== uniqueFilled;
|
|
}
|
|
function shouldDeferIndexType(type) {
|
|
return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && some(type.types, isPossiblyReducibleByInstantiation) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
|
|
}
|
|
function getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
|
|
type = getReducedType(type);
|
|
return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
|
|
type,
|
|
(noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
|
|
stringsOnly === keyofStringsOnly && !noIndexSignatures
|
|
);
|
|
}
|
|
function getExtractStringType(type) {
|
|
if (keyofStringsOnly) {
|
|
return type;
|
|
}
|
|
const extractTypeAlias = getGlobalExtractSymbol();
|
|
return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
|
|
}
|
|
function getIndexTypeOrString(type) {
|
|
const indexType = getExtractStringType(getIndexType(type));
|
|
return indexType.flags & 131072 /* Never */ ? stringType : indexType;
|
|
}
|
|
function getTypeFromTypeOperatorNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
switch (node.operator) {
|
|
case 141 /* KeyOfKeyword */:
|
|
links.resolvedType = getIndexType(getTypeFromTypeNode(node.type));
|
|
break;
|
|
case 156 /* UniqueKeyword */:
|
|
links.resolvedType = node.type.kind === 153 /* SymbolKeyword */ ? getESSymbolLikeTypeForNode(walkUpParenthesizedTypes(node.parent)) : errorType;
|
|
break;
|
|
case 146 /* ReadonlyKeyword */:
|
|
links.resolvedType = getTypeFromTypeNode(node.type);
|
|
break;
|
|
default:
|
|
throw Debug.assertNever(node.operator);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromTemplateTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getTemplateLiteralType(
|
|
[node.head.text, ...map(node.templateSpans, (span) => span.literal.text)],
|
|
map(node.templateSpans, (span) => getTypeFromTypeNode(span.type))
|
|
);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTemplateLiteralType(texts, types) {
|
|
const unionIndex = findIndex(types, (t) => !!(t.flags & (131072 /* Never */ | 1048576 /* Union */)));
|
|
if (unionIndex >= 0) {
|
|
return checkCrossProductUnion(types) ? mapType(types[unionIndex], (t) => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType;
|
|
}
|
|
if (contains(types, wildcardType)) {
|
|
return wildcardType;
|
|
}
|
|
const newTypes = [];
|
|
const newTexts = [];
|
|
let text = texts[0];
|
|
if (!addSpans(texts, types)) {
|
|
return stringType;
|
|
}
|
|
if (newTypes.length === 0) {
|
|
return getStringLiteralType(text);
|
|
}
|
|
newTexts.push(text);
|
|
if (every(newTexts, (t) => t === "")) {
|
|
if (every(newTypes, (t) => !!(t.flags & 4 /* String */))) {
|
|
return stringType;
|
|
}
|
|
if (newTypes.length === 1 && isPatternLiteralType(newTypes[0])) {
|
|
return newTypes[0];
|
|
}
|
|
}
|
|
const id = `${getTypeListId(newTypes)}|${map(newTexts, (t) => t.length).join(",")}|${newTexts.join("")}`;
|
|
let type = templateLiteralTypes.get(id);
|
|
if (!type) {
|
|
templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes));
|
|
}
|
|
return type;
|
|
function addSpans(texts2, types2) {
|
|
const isTextsArray = isArray(texts2);
|
|
for (let i = 0; i < types2.length; i++) {
|
|
const t = types2[i];
|
|
const addText = isTextsArray ? texts2[i + 1] : texts2;
|
|
if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
|
|
text += getTemplateStringForType(t) || "";
|
|
text += addText;
|
|
if (!isTextsArray)
|
|
return true;
|
|
} else if (t.flags & 134217728 /* 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 /* Intersection */) {
|
|
const added = addSpans(texts2[i + 1], t.types);
|
|
if (!added)
|
|
return false;
|
|
} else if (isTextsArray) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function getTemplateStringForType(type) {
|
|
return type.flags & 128 /* StringLiteral */ ? type.value : type.flags & 256 /* NumberLiteral */ ? "" + type.value : type.flags & 2048 /* BigIntLiteral */ ? pseudoBigIntToString(type.value) : type.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) ? type.intrinsicName : void 0;
|
|
}
|
|
function createTemplateLiteralType(texts, types) {
|
|
const type = createType(134217728 /* TemplateLiteral */);
|
|
type.texts = texts;
|
|
type.types = types;
|
|
return type;
|
|
}
|
|
function getStringMappingType(symbol, type) {
|
|
return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type : type.flags & (1 /* Any */ | 4 /* String */ | 268435456 /* StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) : type;
|
|
}
|
|
function applyStringMapping(symbol, str) {
|
|
switch (intrinsicTypeKinds.get(symbol.escapedName)) {
|
|
case 0 /* Uppercase */:
|
|
return str.toUpperCase();
|
|
case 1 /* Lowercase */:
|
|
return str.toLowerCase();
|
|
case 2 /* Capitalize */:
|
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
case 3 /* Uncapitalize */:
|
|
return str.charAt(0).toLowerCase() + str.slice(1);
|
|
}
|
|
return str;
|
|
}
|
|
function applyTemplateStringMapping(symbol, texts, types) {
|
|
switch (intrinsicTypeKinds.get(symbol.escapedName)) {
|
|
case 0 /* Uppercase */:
|
|
return [texts.map((t) => t.toUpperCase()), types.map((t) => getStringMappingType(symbol, t))];
|
|
case 1 /* Lowercase */:
|
|
return [texts.map((t) => t.toLowerCase()), types.map((t) => getStringMappingType(symbol, t))];
|
|
case 2 /* Capitalize */:
|
|
return [texts[0] === "" ? texts : [texts[0].charAt(0).toUpperCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
|
|
case 3 /* Uncapitalize */:
|
|
return [texts[0] === "" ? texts : [texts[0].charAt(0).toLowerCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
|
|
}
|
|
return [texts, types];
|
|
}
|
|
function getStringMappingTypeForGenericType(symbol, type) {
|
|
const id = `${getSymbolId(symbol)},${getTypeId(type)}`;
|
|
let result = stringMappingTypes.get(id);
|
|
if (!result) {
|
|
stringMappingTypes.set(id, result = createStringMappingType(symbol, type));
|
|
}
|
|
return result;
|
|
}
|
|
function createStringMappingType(symbol, type) {
|
|
const result = createTypeWithSymbol(268435456 /* StringMapping */, symbol);
|
|
result.type = type;
|
|
return result;
|
|
}
|
|
function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments) {
|
|
const type = createType(8388608 /* IndexedAccess */);
|
|
type.objectType = objectType;
|
|
type.indexType = indexType;
|
|
type.accessFlags = accessFlags;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
return type;
|
|
}
|
|
function isJSLiteralType(type) {
|
|
if (noImplicitAny) {
|
|
return false;
|
|
}
|
|
if (getObjectFlags(type) & 4096 /* JSLiteral */) {
|
|
return true;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return every(type.types, isJSLiteralType);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return some(type.types, isJSLiteralType);
|
|
}
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
const constraint = getResolvedBaseConstraint(type);
|
|
return constraint !== type && isJSLiteralType(constraint);
|
|
}
|
|
return false;
|
|
}
|
|
function getPropertyNameFromIndex(indexType, accessNode) {
|
|
return isTypeUsableAsPropertyName(indexType) ? getPropertyNameFromType(indexType) : accessNode && isPropertyName(accessNode) ? getPropertyNameForPropertyNameNode(accessNode) : void 0;
|
|
}
|
|
function isUncalledFunctionReference(node, symbol) {
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
|
|
const parent = findAncestor(node.parent, (n) => !isAccessExpression(n)) || node.parent;
|
|
if (isCallLikeExpression(parent)) {
|
|
return isCallOrNewExpression(parent) && isIdentifier(node) && hasMatchingArgument(parent, node);
|
|
}
|
|
return every(symbol.declarations, (d) => !isFunctionLike(d) || !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
|
|
}
|
|
return true;
|
|
}
|
|
function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, accessNode, accessFlags) {
|
|
var _a2;
|
|
const accessExpression = accessNode && accessNode.kind === 209 /* ElementAccessExpression */ ? accessNode : void 0;
|
|
const propName = accessNode && isPrivateIdentifier(accessNode) ? void 0 : getPropertyNameFromIndex(indexType, accessNode);
|
|
if (propName !== void 0) {
|
|
if (accessFlags & 256 /* Contextual */) {
|
|
return getTypeOfPropertyOfContextualType(objectType, propName) || anyType;
|
|
}
|
|
const prop = getPropertyOfType(objectType, propName);
|
|
if (prop) {
|
|
if (accessFlags & 64 /* ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) {
|
|
const deprecatedNode = (_a2 = accessExpression == null ? void 0 : accessExpression.argumentExpression) != null ? _a2 : isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode;
|
|
addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName);
|
|
}
|
|
if (accessExpression) {
|
|
markPropertyAsReferenced(prop, accessExpression, isSelfTypeAccess(accessExpression.expression, objectType.symbol));
|
|
if (isAssignmentToReadonlyEntity(accessExpression, prop, getAssignmentTargetKind(accessExpression))) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop));
|
|
return void 0;
|
|
}
|
|
if (accessFlags & 8 /* CacheSymbol */) {
|
|
getNodeLinks(accessNode).resolvedSymbol = prop;
|
|
}
|
|
if (isThisPropertyAccessInConstructor(accessExpression, prop)) {
|
|
return autoType;
|
|
}
|
|
}
|
|
const propType = getTypeOfSymbol(prop);
|
|
return accessExpression && getAssignmentTargetKind(accessExpression) !== 1 /* Definite */ ? getFlowTypeOfReference(accessExpression, propType) : propType;
|
|
}
|
|
if (everyType(objectType, isTupleType) && isNumericLiteralName(propName)) {
|
|
const index = +propName;
|
|
if (accessNode && everyType(objectType, (t) => !t.target.hasRestElement) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
if (isTupleType(objectType)) {
|
|
if (index < 0) {
|
|
error(indexNode, Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value);
|
|
return undefinedType;
|
|
}
|
|
error(
|
|
indexNode,
|
|
Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2,
|
|
typeToString(objectType),
|
|
getTypeReferenceArity(objectType),
|
|
unescapeLeadingUnderscores(propName)
|
|
);
|
|
} else {
|
|
error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(propName), typeToString(objectType));
|
|
}
|
|
}
|
|
if (index >= 0) {
|
|
errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, numberType));
|
|
return mapType(objectType, (t) => {
|
|
const restType = getRestTypeOfTupleType(t) || undefinedType;
|
|
return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([restType, undefinedType]) : restType;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (!(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */)) {
|
|
if (objectType.flags & (1 /* Any */ | 131072 /* Never */)) {
|
|
return objectType;
|
|
}
|
|
const indexInfo = getApplicableIndexInfo(objectType, indexType) || getIndexInfoOfType(objectType, stringType);
|
|
if (indexInfo) {
|
|
if (accessFlags & 2 /* NoIndexSignatures */ && indexInfo.keyType !== numberType) {
|
|
if (accessExpression) {
|
|
error(accessExpression, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
|
|
}
|
|
return void 0;
|
|
}
|
|
if (accessNode && indexInfo.keyType === stringType && !isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
|
|
return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
|
|
}
|
|
errorIfWritingToReadonlyIndex(indexInfo);
|
|
if (accessFlags & 1 /* IncludeUndefined */ && !(objectType.symbol && objectType.symbol.flags & (256 /* RegularEnum */ | 128 /* ConstEnum */) && (indexType.symbol && indexType.flags & 1024 /* EnumLiteral */ && getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
|
|
return getUnionType([indexInfo.type, undefinedType]);
|
|
}
|
|
return indexInfo.type;
|
|
}
|
|
if (indexType.flags & 131072 /* Never */) {
|
|
return neverType;
|
|
}
|
|
if (isJSLiteralType(objectType)) {
|
|
return anyType;
|
|
}
|
|
if (accessExpression && !isConstEnumObjectType(objectType)) {
|
|
if (isObjectLiteralType(objectType)) {
|
|
if (noImplicitAny && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
diagnostics.add(createDiagnosticForNode(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)));
|
|
return undefinedType;
|
|
} else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
|
|
const types = map(objectType.properties, (property) => {
|
|
return getTypeOfSymbol(property);
|
|
});
|
|
return getUnionType(append(types, undefinedType));
|
|
}
|
|
}
|
|
if (objectType.symbol === globalThisSymbol && propName !== void 0 && globalThisSymbol.exports.has(propName) && globalThisSymbol.exports.get(propName).flags & 418 /* BlockScoped */) {
|
|
error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(propName), typeToString(objectType));
|
|
} else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !(accessFlags & 128 /* SuppressNoImplicitAnyError */)) {
|
|
if (propName !== void 0 && typeHasStaticProperty(propName, objectType)) {
|
|
const typeName = typeToString(objectType);
|
|
error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "[" + getTextOfNode(accessExpression.argumentExpression) + "]");
|
|
} else if (getIndexTypeOfType(objectType, numberType)) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number);
|
|
} else {
|
|
let suggestion;
|
|
if (propName !== void 0 && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) {
|
|
if (suggestion !== void 0) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion);
|
|
}
|
|
} else {
|
|
const suggestion2 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType);
|
|
if (suggestion2 !== void 0) {
|
|
error(accessExpression, Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion2);
|
|
} else {
|
|
let errorInfo;
|
|
if (indexType.flags & 1024 /* EnumLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType));
|
|
} else if (indexType.flags & 8192 /* UniqueESSymbol */) {
|
|
const symbolName2 = getFullyQualifiedName(indexType.symbol, accessExpression);
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName2 + "]", typeToString(objectType));
|
|
} else if (indexType.flags & 128 /* StringLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & 256 /* NumberLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType));
|
|
}
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
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(createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
if (isJSLiteralType(objectType)) {
|
|
return anyType;
|
|
}
|
|
if (accessNode) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
if (indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & (4 /* String */ | 8 /* Number */)) {
|
|
error(indexNode, Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
|
|
} else {
|
|
error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
|
|
}
|
|
}
|
|
if (isTypeAny(indexType)) {
|
|
return indexType;
|
|
}
|
|
return void 0;
|
|
function errorIfWritingToReadonlyIndex(indexInfo) {
|
|
if (indexInfo && indexInfo.isReadonly && accessExpression && (isAssignmentTarget(accessExpression) || isDeleteTarget(accessExpression))) {
|
|
error(accessExpression, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
|
|
}
|
|
}
|
|
}
|
|
function getIndexNodeForAccessExpression(accessNode) {
|
|
return accessNode.kind === 209 /* ElementAccessExpression */ ? accessNode.argumentExpression : accessNode.kind === 196 /* IndexedAccessType */ ? accessNode.indexType : accessNode.kind === 164 /* ComputedPropertyName */ ? accessNode.expression : accessNode;
|
|
}
|
|
function isPatternLiteralPlaceholderType(type) {
|
|
return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
|
|
}
|
|
function isPatternLiteralType(type) {
|
|
return !!(type.flags & 134217728 /* TemplateLiteral */) && every(type.types, isPatternLiteralPlaceholderType) || !!(type.flags & 268435456 /* StringMapping */) && isPatternLiteralPlaceholderType(type.type);
|
|
}
|
|
function isGenericType(type) {
|
|
return !!getGenericObjectFlags(type);
|
|
}
|
|
function isGenericObjectType(type) {
|
|
return !!(getGenericObjectFlags(type) & 4194304 /* IsGenericObjectType */);
|
|
}
|
|
function isGenericIndexType(type) {
|
|
return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
|
|
}
|
|
function getGenericObjectFlags(type) {
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
|
|
type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
|
|
}
|
|
return type.objectFlags & 12582912 /* IsGenericType */;
|
|
}
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
|
|
type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | getGenericObjectFlags(type.baseType) | getGenericObjectFlags(type.constraint);
|
|
}
|
|
return type.objectFlags & 12582912 /* IsGenericType */;
|
|
}
|
|
return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
|
|
}
|
|
function getSimplifiedType(type, writing) {
|
|
return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
|
|
}
|
|
function distributeIndexOverObjectType(objectType, indexType, writing) {
|
|
if (objectType.flags & 1048576 /* Union */ || objectType.flags & 2097152 /* Intersection */ && !shouldDeferIndexType(objectType)) {
|
|
const types = map(objectType.types, (t) => getSimplifiedType(getIndexedAccessType(t, indexType), writing));
|
|
return objectType.flags & 2097152 /* Intersection */ || writing ? getIntersectionType(types) : getUnionType(types);
|
|
}
|
|
}
|
|
function distributeObjectOverIndexType(objectType, indexType, writing) {
|
|
if (indexType.flags & 1048576 /* Union */) {
|
|
const types = map(indexType.types, (t) => getSimplifiedType(getIndexedAccessType(objectType, t), writing));
|
|
return writing ? getIntersectionType(types) : getUnionType(types);
|
|
}
|
|
}
|
|
function getSimplifiedIndexedAccessType(type, writing) {
|
|
const cache = writing ? "simplifiedForWriting" : "simplifiedForReading";
|
|
if (type[cache]) {
|
|
return type[cache] === circularConstraintType ? type : type[cache];
|
|
}
|
|
type[cache] = circularConstraintType;
|
|
const objectType = getSimplifiedType(type.objectType, writing);
|
|
const indexType = getSimplifiedType(type.indexType, writing);
|
|
const distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing);
|
|
if (distributedOverIndex) {
|
|
return type[cache] = distributedOverIndex;
|
|
}
|
|
if (!(indexType.flags & 465829888 /* Instantiable */)) {
|
|
const distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing);
|
|
if (distributedOverObject) {
|
|
return type[cache] = distributedOverObject;
|
|
}
|
|
}
|
|
if (isGenericTupleType(objectType) && indexType.flags & 296 /* NumberLike */) {
|
|
const elementType = getElementTypeOfSliceOfTupleType(objectType, indexType.flags & 8 /* Number */ ? 0 : objectType.target.fixedLength, 0, writing);
|
|
if (elementType) {
|
|
return type[cache] = elementType;
|
|
}
|
|
}
|
|
if (isGenericMappedType(objectType)) {
|
|
const nameType = getNameTypeFromMappedType(objectType);
|
|
if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
|
|
return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), (t) => getSimplifiedType(t, writing));
|
|
}
|
|
}
|
|
return type[cache] = type;
|
|
}
|
|
function getSimplifiedConditionalType(type, writing) {
|
|
const checkType = type.checkType;
|
|
const extendsType = type.extendsType;
|
|
const trueType2 = getTrueTypeFromConditionalType(type);
|
|
const falseType2 = getFalseTypeFromConditionalType(type);
|
|
if (falseType2.flags & 131072 /* Never */ && getActualTypeVariable(trueType2) === getActualTypeVariable(checkType)) {
|
|
if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
|
|
return getSimplifiedType(trueType2, writing);
|
|
} else if (isIntersectionEmpty(checkType, extendsType)) {
|
|
return neverType;
|
|
}
|
|
} else if (trueType2.flags & 131072 /* Never */ && getActualTypeVariable(falseType2) === getActualTypeVariable(checkType)) {
|
|
if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
|
|
return neverType;
|
|
} else if (checkType.flags & 1 /* Any */ || isIntersectionEmpty(checkType, extendsType)) {
|
|
return getSimplifiedType(falseType2, writing);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function isIntersectionEmpty(type1, type2) {
|
|
return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072 /* Never */);
|
|
}
|
|
function substituteIndexedMappedType(objectType, index) {
|
|
const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
|
|
const templateMapper = combineTypeMappers(objectType.mapper, mapper);
|
|
return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
|
|
}
|
|
function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
|
|
return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
|
|
}
|
|
function indexTypeLessThan(indexType, limit) {
|
|
return everyType(indexType, (t) => {
|
|
if (t.flags & 384 /* StringOrNumberLiteral */) {
|
|
const propName = getPropertyNameFromType(t);
|
|
if (isNumericLiteralName(propName)) {
|
|
const index = +propName;
|
|
return index >= 0 && index < limit;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
|
|
if (objectType === wildcardType || indexType === wildcardType) {
|
|
return wildcardType;
|
|
}
|
|
if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
|
|
indexType = stringType;
|
|
}
|
|
if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
|
|
accessFlags |= 1 /* IncludeUndefined */;
|
|
if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 196 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
|
|
if (objectType.flags & 3 /* AnyOrUnknown */) {
|
|
return objectType;
|
|
}
|
|
const persistentAccessFlags = accessFlags & 1 /* Persistent */;
|
|
const id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let type = indexedAccessTypes.get(id);
|
|
if (!type) {
|
|
indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments));
|
|
}
|
|
return type;
|
|
}
|
|
const apparentObjectType = getReducedApparentType(objectType);
|
|
if (indexType.flags & 1048576 /* Union */ && !(indexType.flags & 16 /* Boolean */)) {
|
|
const propTypes = [];
|
|
let wasMissingProp = false;
|
|
for (const t of indexType.types) {
|
|
const propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, accessNode, accessFlags | (wasMissingProp ? 128 /* SuppressNoImplicitAnyError */ : 0));
|
|
if (propType) {
|
|
propTypes.push(propType);
|
|
} else if (!accessNode) {
|
|
return void 0;
|
|
} else {
|
|
wasMissingProp = true;
|
|
}
|
|
}
|
|
if (wasMissingProp) {
|
|
return void 0;
|
|
}
|
|
return accessFlags & 4 /* Writing */ ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments) : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* CacheSymbol */ | 64 /* ReportDeprecated */);
|
|
}
|
|
function getTypeFromIndexedAccessTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const objectType = getTypeFromTypeNode(node.objectType);
|
|
const indexType = getTypeFromTypeNode(node.indexType);
|
|
const potentialAlias = getAliasSymbolForTypeNode(node);
|
|
links.resolvedType = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromMappedTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const type = createObjectType(32 /* Mapped */, node.symbol);
|
|
type.declaration = node;
|
|
type.aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol);
|
|
links.resolvedType = type;
|
|
getConstraintTypeFromMappedType(type);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getActualTypeVariable(type) {
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
return type.baseType;
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */ && (type.objectType.flags & 33554432 /* Substitution */ || type.indexType.flags & 33554432 /* Substitution */)) {
|
|
return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType));
|
|
}
|
|
return type;
|
|
}
|
|
function maybeCloneTypeParameter(p) {
|
|
const 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 isTupleTypeNode(node) && length(node.elements) === 1 && !isOptionalTypeNode(node.elements[0]) && !isRestTypeNode(node.elements[0]) && !(isNamedTupleMember(node.elements[0]) && (node.elements[0].questionToken || node.elements[0].dotDotDotToken));
|
|
}
|
|
function unwrapNondistributiveConditionalTuple(root, type) {
|
|
return isTypicalNondistributiveConditional(root) && isTupleType(type) ? getTypeArguments(type)[0] : type;
|
|
}
|
|
function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
|
|
let result;
|
|
let extraTypes;
|
|
let tailCount = 0;
|
|
while (true) {
|
|
if (tailCount === 1e3) {
|
|
error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
|
|
result = errorType;
|
|
break;
|
|
}
|
|
const isUnwrapped = isTypicalNondistributiveConditional(root);
|
|
const checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
|
|
const checkTypeInstantiable = isGenericType(checkType);
|
|
const extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
|
|
if (checkType === wildcardType || extendsType === wildcardType) {
|
|
return wildcardType;
|
|
}
|
|
let combinedMapper;
|
|
if (root.inferTypeParameters) {
|
|
const freshParams = sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
|
|
const freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : void 0;
|
|
const context = createInferenceContext(freshParams, void 0, 0 /* None */);
|
|
if (freshMapper) {
|
|
const freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
|
|
for (const p of freshParams) {
|
|
if (root.inferTypeParameters.indexOf(p) === -1) {
|
|
p.mapper = freshCombinedMapper;
|
|
}
|
|
}
|
|
}
|
|
if (!checkTypeInstantiable) {
|
|
inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
|
|
}
|
|
const innerMapper = combineTypeMappers(freshMapper, context.mapper);
|
|
combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
|
|
}
|
|
const inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType;
|
|
if (!checkTypeInstantiable && !isGenericType(inferredExtendsType)) {
|
|
if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ && !isUnwrapped || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
|
|
if (checkType.flags & 1 /* Any */ && !isUnwrapped) {
|
|
(extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
|
|
}
|
|
const falseType2 = getTypeFromTypeNode(root.node.falseType);
|
|
if (falseType2.flags & 16777216 /* Conditional */) {
|
|
const newRoot = falseType2.root;
|
|
if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
|
|
root = newRoot;
|
|
continue;
|
|
}
|
|
if (canTailRecurse(falseType2, mapper)) {
|
|
continue;
|
|
}
|
|
}
|
|
result = instantiateType(falseType2, mapper);
|
|
break;
|
|
}
|
|
if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
|
|
const trueType2 = getTypeFromTypeNode(root.node.trueType);
|
|
const trueMapper = combinedMapper || mapper;
|
|
if (canTailRecurse(trueType2, trueMapper)) {
|
|
continue;
|
|
}
|
|
result = instantiateType(trueType2, trueMapper);
|
|
break;
|
|
}
|
|
}
|
|
result = createType(16777216 /* 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);
|
|
break;
|
|
}
|
|
return extraTypes ? getUnionType(append(extraTypes, result)) : result;
|
|
function canTailRecurse(newType, newMapper) {
|
|
if (newType.flags & 16777216 /* Conditional */ && newMapper) {
|
|
const newRoot = newType.root;
|
|
if (newRoot.outerTypeParameters) {
|
|
const typeParamMapper = combineTypeMappers(newType.mapper, newMapper);
|
|
const typeArguments = map(newRoot.outerTypeParameters, (t) => getMappedType(t, typeParamMapper));
|
|
const newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments);
|
|
const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : void 0;
|
|
if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 /* Union */ | 131072 /* Never */))) {
|
|
root = newRoot;
|
|
mapper = newRootMapper;
|
|
aliasSymbol = void 0;
|
|
aliasTypeArguments = void 0;
|
|
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) {
|
|
let result;
|
|
if (node.locals) {
|
|
node.locals.forEach((symbol) => {
|
|
if (symbol.flags & 262144 /* TypeParameter */) {
|
|
result = 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) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const checkType = getTypeFromTypeNode(node.checkType);
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
const allOuterTypeParameters = getOuterTypeParameters(node, true);
|
|
const outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : filter(allOuterTypeParameters, (tp) => isTypeParameterPossiblyReferenced(tp, node));
|
|
const root = {
|
|
node,
|
|
checkType,
|
|
extendsType: getTypeFromTypeNode(node.extendsType),
|
|
isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
|
|
inferTypeParameters: getInferTypeParameters(node),
|
|
outerTypeParameters,
|
|
instantiations: void 0,
|
|
aliasSymbol,
|
|
aliasTypeArguments
|
|
};
|
|
links.resolvedType = getConditionalType(root, void 0);
|
|
if (outerTypeParameters) {
|
|
root.instantiations = /* @__PURE__ */ new Map();
|
|
root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromInferTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getIdentifierChain(node) {
|
|
if (isIdentifier(node)) {
|
|
return [node];
|
|
} else {
|
|
return append(getIdentifierChain(node.left), node.right);
|
|
}
|
|
}
|
|
function getTypeFromImportTypeNode(node) {
|
|
var _a2;
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
if (node.isTypeOf && node.typeArguments) {
|
|
error(node, Diagnostics.Type_arguments_cannot_be_used_here);
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
if (!isLiteralImportTypeNode(node)) {
|
|
error(node.argument, Diagnostics.String_literal_expected);
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
const targetMeaning = node.isTypeOf ? 111551 /* Value */ : node.flags & 8388608 /* JSDoc */ ? 111551 /* Value */ | 788968 /* Type */ : 788968 /* Type */;
|
|
const innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal);
|
|
if (!innerModuleSymbol) {
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
const isExportEquals = !!((_a2 = innerModuleSymbol.exports) == null ? void 0 : _a2.get("export=" /* ExportEquals */));
|
|
const moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, false);
|
|
if (!nodeIsMissing(node.qualifier)) {
|
|
const nameStack = getIdentifierChain(node.qualifier);
|
|
let currentNamespace = moduleSymbol;
|
|
let current;
|
|
while (current = nameStack.shift()) {
|
|
const meaning = nameStack.length ? 1920 /* Namespace */ : targetMeaning;
|
|
const mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace));
|
|
const symbolFromVariable = node.isTypeOf || isInJSFile(node) && isExportEquals ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText, false, true) : void 0;
|
|
const symbolFromModule = node.isTypeOf ? void 0 : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
|
|
const next = symbolFromModule != null ? symbolFromModule : symbolFromVariable;
|
|
if (!next) {
|
|
error(current, Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), 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 {
|
|
const errorMessage = targetMeaning === 111551 /* Value */ ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : 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) {
|
|
const resolvedSymbol = resolveSymbol(symbol);
|
|
links.resolvedSymbol = resolvedSymbol;
|
|
if (meaning === 111551 /* Value */) {
|
|
return getTypeOfSymbol(symbol);
|
|
} else {
|
|
return getTypeReferenceType(node, resolvedSymbol);
|
|
}
|
|
}
|
|
function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
|
|
links.resolvedType = emptyTypeLiteralType;
|
|
} else {
|
|
let type = createObjectType(16 /* Anonymous */, node.symbol);
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
if (isJSDocTypeLiteral(node) && node.isArrayType) {
|
|
type = createArrayType(type);
|
|
}
|
|
links.resolvedType = type;
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getAliasSymbolForTypeNode(node) {
|
|
let host2 = node.parent;
|
|
while (isParenthesizedTypeNode(host2) || isJSDocTypeExpression(host2) || isTypeOperatorNode(host2) && host2.operator === 146 /* ReadonlyKeyword */) {
|
|
host2 = host2.parent;
|
|
}
|
|
return isTypeAlias(host2) ? getSymbolOfNode(host2) : void 0;
|
|
}
|
|
function getTypeArgumentsForAliasSymbol(symbol) {
|
|
return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : void 0;
|
|
}
|
|
function isNonGenericObjectType(type) {
|
|
return !!(type.flags & 524288 /* Object */) && !isGenericMappedType(type);
|
|
}
|
|
function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) {
|
|
return isEmptyObjectType(type) || !!(type.flags & (65536 /* Null */ | 32768 /* Undefined */ | 528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */));
|
|
}
|
|
function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) {
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
return type;
|
|
}
|
|
if (every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) {
|
|
return find(type.types, isEmptyObjectType) || emptyObjectType;
|
|
}
|
|
const firstType = find(type.types, (t) => !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t));
|
|
if (!firstType) {
|
|
return type;
|
|
}
|
|
const secondType = find(type.types, (t) => t !== firstType && !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t));
|
|
if (secondType) {
|
|
return type;
|
|
}
|
|
return getAnonymousPartialType(firstType);
|
|
function getAnonymousPartialType(type2) {
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfType(type2)) {
|
|
if (getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) {
|
|
} else if (isSpreadableProperty(prop)) {
|
|
const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
const flags = 4 /* Property */ | 16777216 /* Optional */;
|
|
const result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* Readonly */ : 0));
|
|
result.type = isSetonlyAccessor ? undefinedType : addOptionality(getTypeOfSymbol(prop), true);
|
|
result.declarations = prop.declarations;
|
|
result.nameType = getSymbolLinks(prop).nameType;
|
|
result.syntheticOrigin = prop;
|
|
members.set(prop.escapedName, result);
|
|
}
|
|
}
|
|
const spread = createAnonymousType(type2.symbol, members, emptyArray, emptyArray, getIndexInfosOfType(type2));
|
|
spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
return spread;
|
|
}
|
|
}
|
|
function getSpreadType(left, right, symbol, objectFlags, readonly) {
|
|
if (left.flags & 1 /* Any */ || right.flags & 1 /* Any */) {
|
|
return anyType;
|
|
}
|
|
if (left.flags & 2 /* Unknown */ || right.flags & 2 /* Unknown */) {
|
|
return unknownType;
|
|
}
|
|
if (left.flags & 131072 /* Never */) {
|
|
return right;
|
|
}
|
|
if (right.flags & 131072 /* Never */) {
|
|
return left;
|
|
}
|
|
left = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly);
|
|
if (left.flags & 1048576 /* Union */) {
|
|
return checkCrossProductUnion([left, right]) ? mapType(left, (t) => getSpreadType(t, right, symbol, objectFlags, readonly)) : errorType;
|
|
}
|
|
right = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly);
|
|
if (right.flags & 1048576 /* Union */) {
|
|
return checkCrossProductUnion([left, right]) ? mapType(right, (t) => getSpreadType(left, t, symbol, objectFlags, readonly)) : errorType;
|
|
}
|
|
if (right.flags & (528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */)) {
|
|
return left;
|
|
}
|
|
if (isGenericObjectType(left) || isGenericObjectType(right)) {
|
|
if (isEmptyObjectType(left)) {
|
|
return right;
|
|
}
|
|
if (left.flags & 2097152 /* Intersection */) {
|
|
const types = left.types;
|
|
const lastLeft = types[types.length - 1];
|
|
if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) {
|
|
return getIntersectionType(concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)]));
|
|
}
|
|
}
|
|
return getIntersectionType([left, right]);
|
|
}
|
|
const members = createSymbolTable();
|
|
const skippedPrivateMembers = /* @__PURE__ */ new Set();
|
|
const indexInfos = left === emptyObjectType ? getIndexInfosOfType(right) : getUnionIndexInfos([left, right]);
|
|
for (const rightProp of getPropertiesOfType(right)) {
|
|
if (getDeclarationModifierFlagsFromSymbol(rightProp) & (8 /* Private */ | 16 /* Protected */)) {
|
|
skippedPrivateMembers.add(rightProp.escapedName);
|
|
} else if (isSpreadableProperty(rightProp)) {
|
|
members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
|
|
}
|
|
}
|
|
for (const leftProp of getPropertiesOfType(left)) {
|
|
if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) {
|
|
continue;
|
|
}
|
|
if (members.has(leftProp.escapedName)) {
|
|
const rightProp = members.get(leftProp.escapedName);
|
|
const rightType = getTypeOfSymbol(rightProp);
|
|
if (rightProp.flags & 16777216 /* Optional */) {
|
|
const declarations = concatenate(leftProp.declarations, rightProp.declarations);
|
|
const flags = 4 /* Property */ | leftProp.flags & 16777216 /* Optional */;
|
|
const result = createSymbol(flags, leftProp.escapedName);
|
|
result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* 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));
|
|
}
|
|
}
|
|
const spread = createAnonymousType(symbol, members, emptyArray, emptyArray, sameMap(indexInfos, (info) => getIndexInfoWithReadonly(info, readonly)));
|
|
spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */ | 2097152 /* ContainsSpread */ | objectFlags;
|
|
return spread;
|
|
}
|
|
function isSpreadableProperty(prop) {
|
|
var _a2;
|
|
return !some(prop.declarations, isPrivateIdentifierClassElementDeclaration) && (!(prop.flags & (8192 /* Method */ | 32768 /* GetAccessor */ | 65536 /* SetAccessor */)) || !((_a2 = prop.declarations) == null ? void 0 : _a2.some((decl) => isClassLike(decl.parent))));
|
|
}
|
|
function getSpreadSymbol(prop, readonly) {
|
|
const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) {
|
|
return prop;
|
|
}
|
|
const flags = 4 /* Property */ | prop.flags & 16777216 /* Optional */;
|
|
const result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* 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) {
|
|
const type = createTypeWithSymbol(flags, symbol);
|
|
type.value = value;
|
|
type.regularType = regularType || type;
|
|
return type;
|
|
}
|
|
function getFreshTypeOfLiteralType(type) {
|
|
if (type.flags & 2944 /* Literal */) {
|
|
if (!type.freshType) {
|
|
const 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 /* Literal */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
|
|
}
|
|
function isFreshLiteralType(type) {
|
|
return !!(type.flags & 2944 /* Literal */) && type.freshType === type;
|
|
}
|
|
function getStringLiteralType(value) {
|
|
let type;
|
|
return stringLiteralTypes.get(value) || (stringLiteralTypes.set(value, type = createLiteralType(128 /* StringLiteral */, value)), type);
|
|
}
|
|
function getNumberLiteralType(value) {
|
|
let type;
|
|
return numberLiteralTypes.get(value) || (numberLiteralTypes.set(value, type = createLiteralType(256 /* NumberLiteral */, value)), type);
|
|
}
|
|
function getBigIntLiteralType(value) {
|
|
let type;
|
|
const key = pseudoBigIntToString(value);
|
|
return bigIntLiteralTypes.get(key) || (bigIntLiteralTypes.set(key, type = createLiteralType(2048 /* BigIntLiteral */, value)), type);
|
|
}
|
|
function getEnumLiteralType(value, enumId, symbol) {
|
|
let type;
|
|
const key = `${enumId}${typeof value === "string" ? "@" : "#"}${value}`;
|
|
const flags = 1024 /* EnumLiteral */ | (typeof value === "string" ? 128 /* StringLiteral */ : 256 /* NumberLiteral */);
|
|
return enumLiteralTypes.get(key) || (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type);
|
|
}
|
|
function getTypeFromLiteralTypeNode(node) {
|
|
if (node.literal.kind === 104 /* NullKeyword */) {
|
|
return nullType;
|
|
}
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function createUniqueESSymbolType(symbol) {
|
|
const type = createTypeWithSymbol(8192 /* UniqueESSymbol */, symbol);
|
|
type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
|
|
return type;
|
|
}
|
|
function getESSymbolLikeTypeForNode(node) {
|
|
if (isValidESSymbolDeclaration(node)) {
|
|
const symbol = isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node);
|
|
if (symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
|
|
}
|
|
}
|
|
return esSymbolType;
|
|
}
|
|
function getThisType(node) {
|
|
const container = getThisContainer(node, false);
|
|
const parent = container && container.parent;
|
|
if (parent && (isClassLike(parent) || parent.kind === 261 /* InterfaceDeclaration */)) {
|
|
if (!isStatic(container) && (!isConstructorDeclaration(container) || isNodeDescendantOf(node, container.body))) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
|
|
}
|
|
}
|
|
if (parent && isObjectLiteralExpression(parent) && isBinaryExpression(parent.parent) && getAssignmentDeclarationKind(parent.parent) === 6 /* Prototype */) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent.parent.left).parent).thisType;
|
|
}
|
|
const host2 = node.flags & 8388608 /* JSDoc */ ? getHostSignatureFromJSDoc(node) : void 0;
|
|
if (host2 && isFunctionExpression(host2) && isBinaryExpression(host2.parent) && getAssignmentDeclarationKind(host2.parent) === 3 /* PrototypeProperty */) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host2.parent.left).parent).thisType;
|
|
}
|
|
if (isJSConstructor(container) && isNodeDescendantOf(node, container.body)) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType;
|
|
}
|
|
error(node, Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
|
|
return errorType;
|
|
}
|
|
function getTypeFromThisTypeNode(node) {
|
|
const 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 /* ParenthesizedType */:
|
|
return getArrayElementTypeNode(node.type);
|
|
case 186 /* TupleType */:
|
|
if (node.elements.length === 1) {
|
|
node = node.elements[0];
|
|
if (node.kind === 188 /* RestType */ || node.kind === 199 /* NamedTupleMember */ && node.dotDotDotToken) {
|
|
return getArrayElementTypeNode(node.type);
|
|
}
|
|
}
|
|
break;
|
|
case 185 /* ArrayType */:
|
|
return node.elementType;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeFromNamedTupleTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
return links.resolvedType || (links.resolvedType = node.dotDotDotToken ? getTypeFromRestTypeNode(node) : addOptionality(getTypeFromTypeNode(node.type), true, !!node.questionToken));
|
|
}
|
|
function getTypeFromTypeNode(node) {
|
|
return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node);
|
|
}
|
|
function getTypeFromTypeNodeWorker(node) {
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
return anyType;
|
|
case 157 /* UnknownKeyword */:
|
|
return unknownType;
|
|
case 152 /* StringKeyword */:
|
|
return stringType;
|
|
case 148 /* NumberKeyword */:
|
|
return numberType;
|
|
case 160 /* BigIntKeyword */:
|
|
return bigintType;
|
|
case 134 /* BooleanKeyword */:
|
|
return booleanType;
|
|
case 153 /* SymbolKeyword */:
|
|
return esSymbolType;
|
|
case 114 /* VoidKeyword */:
|
|
return voidType;
|
|
case 155 /* UndefinedKeyword */:
|
|
return undefinedType;
|
|
case 104 /* NullKeyword */:
|
|
return nullType;
|
|
case 144 /* NeverKeyword */:
|
|
return neverType;
|
|
case 149 /* ObjectKeyword */:
|
|
return node.flags & 262144 /* JavaScriptFile */ && !noImplicitAny ? anyType : nonPrimitiveType;
|
|
case 139 /* IntrinsicKeyword */:
|
|
return intrinsicMarkerType;
|
|
case 194 /* ThisType */:
|
|
case 108 /* ThisKeyword */:
|
|
return getTypeFromThisTypeNode(node);
|
|
case 198 /* LiteralType */:
|
|
return getTypeFromLiteralTypeNode(node);
|
|
case 180 /* TypeReference */:
|
|
return getTypeFromTypeReference(node);
|
|
case 179 /* TypePredicate */:
|
|
return node.assertsModifier ? voidType : booleanType;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return getTypeFromTypeReference(node);
|
|
case 183 /* TypeQuery */:
|
|
return getTypeFromTypeQueryNode(node);
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return getTypeFromArrayOrTupleTypeNode(node);
|
|
case 187 /* OptionalType */:
|
|
return getTypeFromOptionalTypeNode(node);
|
|
case 189 /* UnionType */:
|
|
return getTypeFromUnionTypeNode(node);
|
|
case 190 /* IntersectionType */:
|
|
return getTypeFromIntersectionTypeNode(node);
|
|
case 317 /* JSDocNullableType */:
|
|
return getTypeFromJSDocNullableTypeNode(node);
|
|
case 319 /* JSDocOptionalType */:
|
|
return addOptionality(getTypeFromTypeNode(node.type));
|
|
case 199 /* NamedTupleMember */:
|
|
return getTypeFromNamedTupleTypeNode(node);
|
|
case 193 /* ParenthesizedType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 312 /* JSDocTypeExpression */:
|
|
return getTypeFromTypeNode(node.type);
|
|
case 188 /* RestType */:
|
|
return getTypeFromRestTypeNode(node);
|
|
case 321 /* JSDocVariadicType */:
|
|
return getTypeFromJSDocVariadicType(node);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 326 /* JSDocSignature */:
|
|
return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
|
|
case 195 /* TypeOperator */:
|
|
return getTypeFromTypeOperatorNode(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return getTypeFromIndexedAccessTypeNode(node);
|
|
case 197 /* MappedType */:
|
|
return getTypeFromMappedTypeNode(node);
|
|
case 191 /* ConditionalType */:
|
|
return getTypeFromConditionalTypeNode(node);
|
|
case 192 /* InferType */:
|
|
return getTypeFromInferTypeNode(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return getTypeFromTemplateTypeNode(node);
|
|
case 202 /* ImportType */:
|
|
return getTypeFromImportTypeNode(node);
|
|
case 79 /* Identifier */:
|
|
case 163 /* QualifiedName */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
const symbol = getSymbolAtLocation(node);
|
|
return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
|
|
default:
|
|
return errorType;
|
|
}
|
|
}
|
|
function instantiateList(items, mapper, instantiator) {
|
|
if (items && items.length) {
|
|
for (let i = 0; i < items.length; i++) {
|
|
const item = items[i];
|
|
const mapped = instantiator(item, mapper);
|
|
if (item !== mapped) {
|
|
const 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 /* Simple */:
|
|
return type === mapper.source ? mapper.target : type;
|
|
case 1 /* Array */: {
|
|
const sources = mapper.sources;
|
|
const targets = mapper.targets;
|
|
for (let i = 0; i < sources.length; i++) {
|
|
if (type === sources[i]) {
|
|
return targets ? targets[i] : anyType;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
case 2 /* Deferred */: {
|
|
const sources = mapper.sources;
|
|
const targets = mapper.targets;
|
|
for (let i = 0; i < sources.length; i++) {
|
|
if (type === sources[i]) {
|
|
return targets[i]();
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
case 3 /* Function */:
|
|
return mapper.func(type);
|
|
case 4 /* Composite */:
|
|
case 5 /* Merged */:
|
|
const t1 = getMappedType(type, mapper.mapper1);
|
|
return t1 !== type && mapper.kind === 4 /* Composite */ ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
|
|
}
|
|
}
|
|
function makeUnaryTypeMapper(source, target) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 0 /* Simple */, source, target });
|
|
}
|
|
function makeArrayTypeMapper(sources, targets) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 1 /* Array */, sources, targets });
|
|
}
|
|
function makeFunctionTypeMapper(func, debugInfo) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 3 /* Function */, func, debugInfo: Debug.isDebugging ? debugInfo : void 0 });
|
|
}
|
|
function makeDeferredTypeMapper(sources, targets) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 2 /* Deferred */, sources, targets });
|
|
}
|
|
function makeCompositeTypeMapper(kind, mapper1, mapper2) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind, mapper1, mapper2 });
|
|
}
|
|
function createTypeEraser(sources) {
|
|
return createTypeMapper(sources, void 0);
|
|
}
|
|
function createBackreferenceMapper(context, index) {
|
|
const forwardInferences = context.inferences.slice(index);
|
|
return createTypeMapper(map(forwardInferences, (i) => i.typeParameter), map(forwardInferences, () => unknownType));
|
|
}
|
|
function combineTypeMappers(mapper1, mapper2) {
|
|
return mapper1 ? makeCompositeTypeMapper(4 /* Composite */, mapper1, mapper2) : mapper2;
|
|
}
|
|
function mergeTypeMappers(mapper1, mapper2) {
|
|
return mapper1 ? makeCompositeTypeMapper(5 /* Merged */, mapper1, mapper2) : mapper2;
|
|
}
|
|
function prependTypeMapping(source, target, mapper) {
|
|
return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* Merged */, makeUnaryTypeMapper(source, target), mapper);
|
|
}
|
|
function appendTypeMapping(mapper, source, target) {
|
|
return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* 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) {
|
|
const 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) {
|
|
let freshTypeParameters;
|
|
if (signature.typeParameters && !eraseTypeParameters) {
|
|
freshTypeParameters = map(signature.typeParameters, cloneTypeParameter);
|
|
mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
|
|
for (const tp of freshTypeParameters) {
|
|
tp.mapper = mapper;
|
|
}
|
|
}
|
|
const result = createSignature(
|
|
signature.declaration,
|
|
freshTypeParameters,
|
|
signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper),
|
|
instantiateList(signature.parameters, mapper, instantiateSymbol),
|
|
void 0,
|
|
void 0,
|
|
signature.minArgumentCount,
|
|
signature.flags & 39 /* PropagatingFlags */
|
|
);
|
|
result.target = signature;
|
|
result.mapper = mapper;
|
|
return result;
|
|
}
|
|
function instantiateSymbol(symbol, mapper) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.type && !couldContainTypeVariables(links.type)) {
|
|
return symbol;
|
|
}
|
|
if (getCheckFlags(symbol) & 1 /* Instantiated */) {
|
|
symbol = links.target;
|
|
mapper = combineTypeMappers(links.mapper, mapper);
|
|
}
|
|
const result = createSymbol(symbol.flags, symbol.escapedName, 1 /* Instantiated */ | getCheckFlags(symbol) & (8 /* Readonly */ | 4096 /* Late */ | 16384 /* OptionalParameter */ | 32768 /* 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) {
|
|
const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
|
|
const links = getNodeLinks(declaration);
|
|
const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
|
|
let typeParameters = links.outerTypeParameters;
|
|
if (!typeParameters) {
|
|
let outerTypeParameters = getOuterTypeParameters(declaration, true);
|
|
if (isJSConstructor(declaration)) {
|
|
const templateTagParameters = getTypeParametersFromDeclaration(declaration);
|
|
outerTypeParameters = addRange(outerTypeParameters, templateTagParameters);
|
|
}
|
|
typeParameters = outerTypeParameters || emptyArray;
|
|
const allDeclarations = type.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
|
|
typeParameters = (target.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ? filter(typeParameters, (tp) => some(allDeclarations, (d) => isTypeParameterPossiblyReferenced(tp, d))) : typeParameters;
|
|
links.outerTypeParameters = typeParameters;
|
|
}
|
|
if (typeParameters.length) {
|
|
const combinedMapper = combineTypeMappers(type.mapper, mapper);
|
|
const typeArguments = map(typeParameters, (t) => getMappedType(t, combinedMapper));
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
const id = getTypeListId(typeArguments) + getAliasId(newAliasSymbol, newAliasTypeArguments);
|
|
if (!target.instantiations) {
|
|
target.instantiations = /* @__PURE__ */ new Map();
|
|
target.instantiations.set(getTypeListId(typeParameters) + getAliasId(target.aliasSymbol, target.aliasTypeArguments), target);
|
|
}
|
|
let result = target.instantiations.get(id);
|
|
if (!result) {
|
|
const newMapper = createTypeMapper(typeParameters, typeArguments);
|
|
result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : target.objectFlags & 32 /* 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 /* TypeReference */ && node.parent.typeArguments && node === node.parent.typeName || node.parent.kind === 202 /* ImportType */ && node.parent.typeArguments && node === node.parent.qualifier);
|
|
}
|
|
function isTypeParameterPossiblyReferenced(tp, node) {
|
|
if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
|
|
const container = tp.symbol.declarations[0].parent;
|
|
for (let n = node; n !== container; n = n.parent) {
|
|
if (!n || n.kind === 238 /* Block */ || n.kind === 191 /* ConditionalType */ && forEachChild(n.extendsType, containsReference)) {
|
|
return true;
|
|
}
|
|
}
|
|
return containsReference(node);
|
|
}
|
|
return true;
|
|
function containsReference(node2) {
|
|
switch (node2.kind) {
|
|
case 194 /* ThisType */:
|
|
return !!tp.isThisType;
|
|
case 79 /* Identifier */:
|
|
return !tp.isThisType && isPartOfTypeNode(node2) && maybeTypeParameterReference(node2) && getTypeFromTypeNodeWorker(node2) === tp;
|
|
case 183 /* TypeQuery */:
|
|
const entityName = node2.exprName;
|
|
const firstIdentifier = getFirstIdentifier(entityName);
|
|
const firstIdentifierSymbol = getResolvedSymbol(firstIdentifier);
|
|
const tpDeclaration = tp.symbol.declarations[0];
|
|
let tpScope;
|
|
if (tpDeclaration.kind === 165 /* TypeParameter */) {
|
|
tpScope = tpDeclaration.parent;
|
|
} else if (tp.isThisType) {
|
|
tpScope = tpDeclaration;
|
|
} else {
|
|
return true;
|
|
}
|
|
if (firstIdentifierSymbol.declarations) {
|
|
return some(firstIdentifierSymbol.declarations, (idDecl) => isNodeDescendantOf(idDecl, tpScope)) || some(node2.typeArguments, containsReference);
|
|
}
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return !node2.type && !!node2.body || some(node2.typeParameters, containsReference) || some(node2.parameters, containsReference) || !!node2.type && containsReference(node2.type);
|
|
}
|
|
return !!forEachChild(node2, containsReference);
|
|
}
|
|
}
|
|
function getHomomorphicTypeVariable(type) {
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
if (constraintType.flags & 4194304 /* Index */) {
|
|
const typeVariable = getActualTypeVariable(constraintType.type);
|
|
if (typeVariable.flags & 262144 /* TypeParameter */) {
|
|
return typeVariable;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function instantiateMappedType(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const typeVariable = getHomomorphicTypeVariable(type);
|
|
if (typeVariable) {
|
|
const mappedTypeVariable = instantiateType(typeVariable, mapper);
|
|
if (typeVariable !== mappedTypeVariable) {
|
|
return mapTypeWithAlias(getReducedType(mappedTypeVariable), (t) => {
|
|
if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
|
|
if (!type.declaration.nameType) {
|
|
let constraint;
|
|
if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* 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);
|
|
}
|
|
}
|
|
return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
function getModifiedReadonlyState(state, modifiers) {
|
|
return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state;
|
|
}
|
|
function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
|
|
const elementFlags = tupleType.target.elementFlags;
|
|
const elementTypes = map(getTypeArguments(tupleType), (t, i) => {
|
|
const singleton = elementFlags[i] & 8 /* Variadic */ ? t : elementFlags[i] & 4 /* Rest */ ? createArrayType(t) : createTupleType([t], [elementFlags[i]]);
|
|
return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
|
|
});
|
|
const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType));
|
|
return createTupleType(elementTypes, map(elementTypes, (_) => 8 /* Variadic */), newReadonly);
|
|
}
|
|
function instantiateMappedArrayType(arrayType, mappedType, mapper) {
|
|
const elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper);
|
|
return isErrorType(elementType) ? errorType : createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
|
|
}
|
|
function instantiateMappedTupleType(tupleType, mappedType, mapper) {
|
|
const elementFlags = tupleType.target.elementFlags;
|
|
const elementTypes = map(getTypeArguments(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
|
|
const modifiers = getMappedTypeModifiers(mappedType);
|
|
const newTupleModifiers = modifiers & 4 /* IncludeOptional */ ? map(elementFlags, (f) => f & 1 /* Required */ ? 2 /* Optional */ : f) : modifiers & 8 /* ExcludeOptional */ ? map(elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : elementFlags;
|
|
const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
|
|
return contains(elementTypes, errorType) ? errorType : createTupleType(elementTypes, newTupleModifiers, newReadonly, tupleType.target.labeledElementDeclarations);
|
|
}
|
|
function instantiateMappedTypeTemplate(type, key, isOptional, mapper) {
|
|
const templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key);
|
|
const propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper);
|
|
const modifiers = getMappedTypeModifiers(type);
|
|
return strictNullChecks && modifiers & 4 /* IncludeOptional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(propType, true) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
|
|
}
|
|
function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const result = createObjectType(type.objectFlags | 64 /* Instantiated */, type.symbol);
|
|
if (type.objectFlags & 32 /* Mapped */) {
|
|
result.declaration = type.declaration;
|
|
const origTypeParameter = getTypeParameterFromMappedType(type);
|
|
const freshTypeParameter = cloneTypeParameter(origTypeParameter);
|
|
result.typeParameter = freshTypeParameter;
|
|
mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
|
|
freshTypeParameter.mapper = mapper;
|
|
}
|
|
if (type.objectFlags & 8388608 /* 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) {
|
|
const root = type.root;
|
|
if (root.outerTypeParameters) {
|
|
const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
|
|
const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let result = root.instantiations.get(id);
|
|
if (!result) {
|
|
const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
|
|
const checkType = root.checkType;
|
|
const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
|
|
result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
|
|
root.instantiations.set(id, result);
|
|
}
|
|
return result;
|
|
}
|
|
return type;
|
|
}
|
|
function instantiateType(type, mapper) {
|
|
return type && mapper ? instantiateTypeWithAlias(type, mapper, void 0, void 0) : type;
|
|
}
|
|
function instantiateTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
var _a2;
|
|
if (!couldContainTypeVariables(type)) {
|
|
return type;
|
|
}
|
|
if (instantiationDepth === 100 || instantiationCount >= 5e6) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth, instantiationCount });
|
|
error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
|
|
return errorType;
|
|
}
|
|
totalInstantiationCount++;
|
|
instantiationCount++;
|
|
instantiationDepth++;
|
|
const result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments);
|
|
instantiationDepth--;
|
|
return result;
|
|
}
|
|
function instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const flags = type.flags;
|
|
if (flags & 262144 /* TypeParameter */) {
|
|
return getMappedType(type, mapper);
|
|
}
|
|
if (flags & 524288 /* Object */) {
|
|
const objectFlags = type.objectFlags;
|
|
if (objectFlags & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */)) {
|
|
if (objectFlags & 4 /* Reference */ && !type.node) {
|
|
const resolvedTypeArguments = type.resolvedTypeArguments;
|
|
const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper);
|
|
return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type;
|
|
}
|
|
if (objectFlags & 1024 /* ReverseMapped */) {
|
|
return instantiateReverseMappedType(type, mapper);
|
|
}
|
|
return getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
return type;
|
|
}
|
|
if (flags & 3145728 /* UnionOrIntersection */) {
|
|
const origin = type.flags & 1048576 /* Union */ ? type.origin : void 0;
|
|
const types = origin && origin.flags & 3145728 /* UnionOrIntersection */ ? origin.types : type.types;
|
|
const newTypes = instantiateTypes(types, mapper);
|
|
if (newTypes === types && aliasSymbol === type.aliasSymbol) {
|
|
return type;
|
|
}
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
return flags & 2097152 /* Intersection */ || origin && origin.flags & 2097152 /* Intersection */ ? getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments) : getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments);
|
|
}
|
|
if (flags & 4194304 /* Index */) {
|
|
return getIndexType(instantiateType(type.type, mapper));
|
|
}
|
|
if (flags & 134217728 /* TemplateLiteral */) {
|
|
return getTemplateLiteralType(type.texts, instantiateTypes(type.types, mapper));
|
|
}
|
|
if (flags & 268435456 /* StringMapping */) {
|
|
return getStringMappingType(type.symbol, instantiateType(type.type, mapper));
|
|
}
|
|
if (flags & 8388608 /* IndexedAccess */) {
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, void 0, newAliasSymbol, newAliasTypeArguments);
|
|
}
|
|
if (flags & 16777216 /* Conditional */) {
|
|
return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
|
|
}
|
|
if (flags & 33554432 /* Substitution */) {
|
|
const newBaseType = instantiateType(type.baseType, mapper);
|
|
const newConstraint = instantiateType(type.constraint, mapper);
|
|
if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
|
|
return getSubstitutionType(newBaseType, newConstraint);
|
|
}
|
|
if (newConstraint.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(newBaseType), getRestrictiveInstantiation(newConstraint))) {
|
|
return newBaseType;
|
|
}
|
|
return newBaseType.flags & 8650752 /* TypeVariable */ ? getSubstitutionType(newBaseType, newConstraint) : getIntersectionType([newConstraint, newBaseType]);
|
|
}
|
|
return type;
|
|
}
|
|
function instantiateReverseMappedType(type, mapper) {
|
|
const innerMappedType = instantiateType(type.mappedType, mapper);
|
|
if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
|
|
return type;
|
|
}
|
|
const innerIndexType = instantiateType(type.constraintType, mapper);
|
|
if (!(innerIndexType.flags & 4194304 /* Index */)) {
|
|
return type;
|
|
}
|
|
const instantiated = inferTypeForHomomorphicMappedType(
|
|
instantiateType(type.source, mapper),
|
|
innerMappedType,
|
|
innerIndexType
|
|
);
|
|
if (instantiated) {
|
|
return instantiated;
|
|
}
|
|
return type;
|
|
}
|
|
function getUniqueLiteralFilledInstantiation(type) {
|
|
return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
|
|
}
|
|
function getPermissiveInstantiation(type) {
|
|
return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
|
|
}
|
|
function getRestrictiveInstantiation(type) {
|
|
if (type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */)) {
|
|
return type;
|
|
}
|
|
if (type.restrictiveInstantiation) {
|
|
return type.restrictiveInstantiation;
|
|
}
|
|
type.restrictiveInstantiation = instantiateType(type, restrictiveMapper);
|
|
type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation;
|
|
return type.restrictiveInstantiation;
|
|
}
|
|
function instantiateIndexInfo(info, mapper) {
|
|
return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration);
|
|
}
|
|
function isContextSensitive(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
switch (node.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return isContextSensitiveFunctionLikeDeclaration(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return some(node.properties, isContextSensitive);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return some(node.elements, isContextSensitive);
|
|
case 224 /* ConditionalExpression */:
|
|
return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse);
|
|
case 223 /* BinaryExpression */:
|
|
return (node.operatorToken.kind === 56 /* BarBarToken */ || node.operatorToken.kind === 60 /* QuestionQuestionToken */) && (isContextSensitive(node.left) || isContextSensitive(node.right));
|
|
case 299 /* PropertyAssignment */:
|
|
return isContextSensitive(node.initializer);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isContextSensitive(node.expression);
|
|
case 289 /* JsxAttributes */:
|
|
return some(node.properties, isContextSensitive) || isJsxOpeningElement(node.parent) && some(node.parent.parent.children, isContextSensitive);
|
|
case 288 /* JsxAttribute */: {
|
|
const { initializer } = node;
|
|
return !!initializer && isContextSensitive(initializer);
|
|
}
|
|
case 291 /* JsxExpression */: {
|
|
const { expression } = node;
|
|
return !!expression && isContextSensitive(expression);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isContextSensitiveFunctionLikeDeclaration(node) {
|
|
return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
|
|
}
|
|
function hasContextSensitiveReturnExpression(node) {
|
|
return !node.typeParameters && !getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 238 /* Block */ && isContextSensitive(node.body);
|
|
}
|
|
function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
|
|
return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);
|
|
}
|
|
function getTypeWithoutSignatures(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
if (resolved.constructSignatures.length || resolved.callSignatures.length) {
|
|
const result = createObjectType(16 /* Anonymous */, type.symbol);
|
|
result.members = resolved.members;
|
|
result.properties = resolved.properties;
|
|
result.callSignatures = emptyArray;
|
|
result.constructSignatures = emptyArray;
|
|
result.indexInfos = emptyArray;
|
|
return result;
|
|
}
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(map(type.types, getTypeWithoutSignatures));
|
|
}
|
|
return type;
|
|
}
|
|
function isTypeIdenticalTo(source, target) {
|
|
return isTypeRelatedTo(source, target, identityRelation);
|
|
}
|
|
function compareTypesIdentical(source, target) {
|
|
return isTypeRelatedTo(source, target, identityRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function compareTypesAssignable(source, target) {
|
|
return isTypeRelatedTo(source, target, assignableRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function compareTypesSubtypeOf(source, target) {
|
|
return isTypeRelatedTo(source, target, subtypeRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function isTypeSubtypeOf(source, target) {
|
|
return isTypeRelatedTo(source, target, subtypeRelation);
|
|
}
|
|
function isTypeAssignableTo(source, target) {
|
|
return isTypeRelatedTo(source, target, assignableRelation);
|
|
}
|
|
function isTypeDerivedFrom(source, target) {
|
|
return source.flags & 1048576 /* Union */ ? every(source.types, (t) => isTypeDerivedFrom(t, target)) : target.flags & 1048576 /* Union */ ? some(target.types, (t) => isTypeDerivedFrom(source, t)) : source.flags & 2097152 /* Intersection */ ? some(source.types, (t) => isTypeDerivedFrom(t, target)) : source.flags & 58982400 /* InstantiableNonPrimitive */ ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) : isEmptyAnonymousObjectType(target) ? !!(source.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */)) : target === globalObjectType ? !!(source.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */)) && !isEmptyAnonymousObjectType(source) : target === globalFunctionType ? !!(source.flags & 524288 /* Object */) && isFunctionObjectType(source) : hasBaseType(source, getTargetType(target)) || isArrayType(target) && !isReadonlyArrayType(target) && isTypeDerivedFrom(source, globalReadonlyArrayType);
|
|
}
|
|
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);
|
|
}
|
|
function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) {
|
|
return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, void 0);
|
|
}
|
|
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 /* Conditional */ || type.flags & 2097152 /* Intersection */ && some(type.types, isOrHasGenericConditional));
|
|
}
|
|
function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
|
|
if (!node || isOrHasGenericConditional(target))
|
|
return false;
|
|
if (!checkTypeRelatedTo(source, target, relation, void 0) && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) {
|
|
return true;
|
|
}
|
|
switch (node.kind) {
|
|
case 291 /* JsxExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
|
|
case 223 /* BinaryExpression */:
|
|
switch (node.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 27 /* CommaToken */:
|
|
return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
|
|
}
|
|
break;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 289 /* JsxAttributes */:
|
|
return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 216 /* ArrowFunction */:
|
|
return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
return false;
|
|
}
|
|
function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
|
|
const callSignatures = getSignaturesOfType(source, 0 /* Call */);
|
|
const constructSignatures = getSignaturesOfType(source, 1 /* Construct */);
|
|
for (const signatures of [constructSignatures, callSignatures]) {
|
|
if (some(signatures, (s) => {
|
|
const returnType = getReturnTypeOfSignature(s);
|
|
return !(returnType.flags & (1 /* Any */ | 131072 /* Never */)) && checkTypeRelatedTo(returnType, target, relation, void 0);
|
|
})) {
|
|
const resultObj = errorOutputContainer || {};
|
|
checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj);
|
|
const diagnostic = resultObj.errors[resultObj.errors.length - 1];
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(
|
|
node,
|
|
signatures === constructSignatures ? Diagnostics.Did_you_mean_to_use_new_with_this_expression : Diagnostics.Did_you_mean_to_call_this_expression
|
|
));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (isBlock(node.body)) {
|
|
return false;
|
|
}
|
|
if (some(node.parameters, hasType)) {
|
|
return false;
|
|
}
|
|
const sourceSig = getSingleCallSignature(source);
|
|
if (!sourceSig) {
|
|
return false;
|
|
}
|
|
const targetSignatures = getSignaturesOfType(target, 0 /* Call */);
|
|
if (!length(targetSignatures)) {
|
|
return false;
|
|
}
|
|
const returnExpression = node.body;
|
|
const sourceReturn = getReturnTypeOfSignature(sourceSig);
|
|
const targetReturn = getUnionType(map(targetSignatures, getReturnTypeOfSignature));
|
|
if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, void 0)) {
|
|
const elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, void 0, containingMessageChain, errorOutputContainer);
|
|
if (elaborated) {
|
|
return elaborated;
|
|
}
|
|
const resultObj = errorOutputContainer || {};
|
|
checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, void 0, containingMessageChain, resultObj);
|
|
if (resultObj.errors) {
|
|
if (target.symbol && length(target.symbol.declarations)) {
|
|
addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], createDiagnosticForNode(
|
|
target.symbol.declarations[0],
|
|
Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature
|
|
));
|
|
}
|
|
if ((getFunctionFlags(node) & 2 /* Async */) === 0 && !getTypeOfPropertyOfType(sourceReturn, "then") && checkTypeRelatedTo(createPromiseType(sourceReturn), targetReturn, relation, void 0)) {
|
|
addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], createDiagnosticForNode(
|
|
node,
|
|
Diagnostics.Did_you_mean_to_mark_this_function_as_async
|
|
));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) {
|
|
const idx = getIndexedAccessTypeOrUndefined(target, nameType);
|
|
if (idx) {
|
|
return idx;
|
|
}
|
|
if (target.flags & 1048576 /* Union */) {
|
|
const best = getBestMatchingType(source, target);
|
|
if (best) {
|
|
return getIndexedAccessTypeOrUndefined(best, nameType);
|
|
}
|
|
}
|
|
}
|
|
function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
|
|
next.contextualType = sourcePropType;
|
|
try {
|
|
return checkExpressionForMutableLocation(next, 1 /* Contextual */, sourcePropType);
|
|
} finally {
|
|
next.contextualType = void 0;
|
|
}
|
|
}
|
|
function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
let reportedError = false;
|
|
for (let status = iterator.next(); !status.done; status = iterator.next()) {
|
|
const { errorNode: prop, innerExpression: next, nameType, errorMessage } = status.value;
|
|
let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
|
|
if (!targetPropType || targetPropType.flags & 8388608 /* IndexedAccess */)
|
|
continue;
|
|
let sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
|
|
if (!sourcePropType)
|
|
continue;
|
|
const propName = getPropertyNameFromIndex(nameType, void 0);
|
|
if (!checkTypeRelatedTo(sourcePropType, targetPropType, relation, void 0)) {
|
|
const elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, void 0, containingMessageChain, errorOutputContainer);
|
|
reportedError = true;
|
|
if (!elaborated) {
|
|
const resultObj = errorOutputContainer || {};
|
|
const specificSource = next ? checkExpressionForMutableLocationWithContextualType(next, sourcePropType) : sourcePropType;
|
|
if (exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(specificSource, targetPropType)) {
|
|
const diag2 = createDiagnosticForNode(prop, 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(diag2);
|
|
resultObj.errors = [diag2];
|
|
} else {
|
|
const targetIsOptional = !!(propName && (getPropertyOfType(target, propName) || unknownSymbol).flags & 16777216 /* Optional */);
|
|
const sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & 16777216 /* Optional */);
|
|
targetPropType = removeMissingType(targetPropType, targetIsOptional);
|
|
sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
|
|
const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
|
|
if (result && specificSource !== sourcePropType) {
|
|
checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
|
|
}
|
|
}
|
|
if (resultObj.errors) {
|
|
const reportedDiag = resultObj.errors[resultObj.errors.length - 1];
|
|
const propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : void 0;
|
|
const targetProp = propertyName !== void 0 ? getPropertyOfType(target, propertyName) : void 0;
|
|
let issuedElaboration = false;
|
|
if (!targetProp) {
|
|
const indexInfo = getApplicableIndexInfo(target, nameType);
|
|
if (indexInfo && indexInfo.declaration && !getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) {
|
|
issuedElaboration = true;
|
|
addRelatedInfo(reportedDiag, createDiagnosticForNode(indexInfo.declaration, Diagnostics.The_expected_type_comes_from_this_index_signature));
|
|
}
|
|
}
|
|
if (!issuedElaboration && (targetProp && length(targetProp.declarations) || target.symbol && length(target.symbol.declarations))) {
|
|
const targetNode = targetProp && length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0];
|
|
if (!getSourceFileOfNode(targetNode).hasNoDefaultLib) {
|
|
addRelatedInfo(reportedDiag, createDiagnosticForNode(
|
|
targetNode,
|
|
Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1,
|
|
propertyName && !(nameType.flags & 8192 /* UniqueESSymbol */) ? unescapeLeadingUnderscores(propertyName) : typeToString(nameType),
|
|
typeToString(target)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return reportedError;
|
|
}
|
|
function* generateJsxAttributes(node) {
|
|
if (!length(node.properties))
|
|
return;
|
|
for (const prop of node.properties) {
|
|
if (isJsxSpreadAttribute(prop) || isHyphenatedJsxName(idText(prop.name)))
|
|
continue;
|
|
yield { errorNode: prop.name, innerExpression: prop.initializer, nameType: getStringLiteralType(idText(prop.name)) };
|
|
}
|
|
}
|
|
function* generateJsxChildren(node, getInvalidTextDiagnostic) {
|
|
if (!length(node.children))
|
|
return;
|
|
let memberOffset = 0;
|
|
for (let i = 0; i < node.children.length; i++) {
|
|
const child = node.children[i];
|
|
const nameType = getNumberLiteralType(i - memberOffset);
|
|
const elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic);
|
|
if (elem) {
|
|
yield elem;
|
|
} else {
|
|
memberOffset++;
|
|
}
|
|
}
|
|
}
|
|
function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) {
|
|
switch (child.kind) {
|
|
case 291 /* JsxExpression */:
|
|
return { errorNode: child, innerExpression: child.expression, nameType };
|
|
case 11 /* JsxText */:
|
|
if (child.containsOnlyTriviaWhiteSpaces) {
|
|
break;
|
|
}
|
|
return { errorNode: child, innerExpression: void 0, nameType, errorMessage: getInvalidTextDiagnostic() };
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
return { errorNode: child, innerExpression: child, nameType };
|
|
default:
|
|
return Debug.assertNever(child, "Found invalid jsx child");
|
|
}
|
|
}
|
|
function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
let result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
let invalidTextDiagnostic;
|
|
if (isJsxOpeningElement(node.parent) && isJsxElement(node.parent.parent)) {
|
|
const containingElement = node.parent.parent;
|
|
const childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
const childrenPropName = childPropName === void 0 ? "children" : unescapeLeadingUnderscores(childPropName);
|
|
const childrenNameType = getStringLiteralType(childrenPropName);
|
|
const childrenTargetType = getIndexedAccessType(target, childrenNameType);
|
|
const validChildren = getSemanticJsxChildren(containingElement.children);
|
|
if (!length(validChildren)) {
|
|
return result;
|
|
}
|
|
const moreThanOneRealChildren = length(validChildren) > 1;
|
|
const arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
|
|
const nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isArrayOrTupleLikeType(t));
|
|
if (moreThanOneRealChildren) {
|
|
if (arrayLikeTargetParts !== neverType) {
|
|
const realSource = createTupleType(checkJsxChildren(containingElement, 0 /* Normal */));
|
|
const children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic);
|
|
result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result;
|
|
} else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
|
|
result = true;
|
|
const diag2 = error(
|
|
containingElement.openingElement.tagName,
|
|
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(diag2);
|
|
}
|
|
}
|
|
} else {
|
|
if (nonArrayLikeTargetParts !== neverType) {
|
|
const child = validChildren[0];
|
|
const elem = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic);
|
|
if (elem) {
|
|
result = elaborateElementwise(
|
|
function* () {
|
|
yield elem;
|
|
}(),
|
|
source,
|
|
target,
|
|
relation,
|
|
containingMessageChain,
|
|
errorOutputContainer
|
|
) || result;
|
|
}
|
|
} else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
|
|
result = true;
|
|
const diag2 = error(
|
|
containingElement.openingElement.tagName,
|
|
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(diag2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
function getInvalidTextualChildDiagnostic() {
|
|
if (!invalidTextDiagnostic) {
|
|
const tagNameText = getTextOfNode(node.parent.tagName);
|
|
const childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
const childrenPropName = childPropName === void 0 ? "children" : unescapeLeadingUnderscores(childPropName);
|
|
const childrenTargetType = getIndexedAccessType(target, getStringLiteralType(childrenPropName));
|
|
const diagnostic = 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 = { ...diagnostic, key: "!!ALREADY FORMATTED!!", message: formatMessage(void 0, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) };
|
|
}
|
|
return invalidTextDiagnostic;
|
|
}
|
|
}
|
|
function* generateLimitedTupleElements(node, target) {
|
|
const len = length(node.elements);
|
|
if (!len)
|
|
return;
|
|
for (let i = 0; i < len; i++) {
|
|
if (isTupleLikeType(target) && !getPropertyOfType(target, "" + i))
|
|
continue;
|
|
const elem = node.elements[i];
|
|
if (isOmittedExpression(elem))
|
|
continue;
|
|
const nameType = getNumberLiteralType(i);
|
|
yield { errorNode: elem, innerExpression: elem, nameType };
|
|
}
|
|
}
|
|
function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
|
|
return false;
|
|
if (isTupleLikeType(source)) {
|
|
return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
const oldContext = node.contextualType;
|
|
node.contextualType = target;
|
|
try {
|
|
const tupleizedType = checkArrayLiteral(node, 1 /* Contextual */, 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) {
|
|
if (!length(node.properties))
|
|
return;
|
|
for (const prop of node.properties) {
|
|
if (isSpreadAssignment(prop))
|
|
continue;
|
|
const type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576 /* StringOrNumberLiteralOrUnique */);
|
|
if (!type || type.flags & 131072 /* Never */) {
|
|
continue;
|
|
}
|
|
switch (prop.kind) {
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
yield { errorNode: prop.name, innerExpression: void 0, nameType: type };
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
yield { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: isComputedNonLiteralName(prop.name) ? Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : void 0 };
|
|
break;
|
|
default:
|
|
Debug.assertNever(prop);
|
|
}
|
|
}
|
|
}
|
|
function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
|
|
return false;
|
|
return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
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 /* IgnoreReturnTypes */ : 0 /* None */,
|
|
false,
|
|
void 0,
|
|
void 0,
|
|
compareTypesAssignable,
|
|
void 0
|
|
) !== 0 /* False */;
|
|
}
|
|
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));
|
|
}
|
|
function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
|
|
if (source === target) {
|
|
return -1 /* True */;
|
|
}
|
|
if (isAnySignature(target)) {
|
|
return -1 /* True */;
|
|
}
|
|
const targetCount = getParameterCount(target);
|
|
const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
|
|
if (sourceHasMoreParameters) {
|
|
return 0 /* False */;
|
|
}
|
|
if (source.typeParameters && source.typeParameters !== target.typeParameters) {
|
|
target = getCanonicalSignature(target);
|
|
source = instantiateSignatureInContextOf(source, target, void 0, compareTypes);
|
|
}
|
|
const sourceCount = getParameterCount(source);
|
|
const sourceRestType = getNonArrayRestType(source);
|
|
const targetRestType = getNonArrayRestType(target);
|
|
if (sourceRestType || targetRestType) {
|
|
void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers);
|
|
}
|
|
const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
|
|
const strictVariance = !(checkMode & 3 /* Callback */) && strictFunctionTypes && kind !== 171 /* MethodDeclaration */ && kind !== 170 /* MethodSignature */ && kind !== 173 /* Constructor */;
|
|
let result = -1 /* True */;
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType && sourceThisType !== voidType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
const related = !strictVariance && compareTypes(sourceThisType, targetThisType, false) || compareTypes(targetThisType, sourceThisType, reportErrors2);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.The_this_types_of_each_signature_are_incompatible);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
|
|
const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
|
|
for (let i = 0; i < paramCount; i++) {
|
|
const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
|
|
const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
|
|
if (sourceType && targetType) {
|
|
const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
|
|
const targetSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
|
|
const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
|
|
let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(sourceType, targetType, false) || compareTypes(targetType, sourceType, reportErrors2);
|
|
if (related && checkMode & 8 /* StrictArity */ && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, false)) {
|
|
related = 0 /* False */;
|
|
}
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
errorReporter(
|
|
Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
|
|
unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)),
|
|
unescapeLeadingUnderscores(getParameterNameAtPosition(target, i))
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
if (!(checkMode & 4 /* IgnoreReturnTypes */)) {
|
|
const targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol)) : getReturnTypeOfSignature(target);
|
|
if (targetReturnType === voidType || targetReturnType === anyType) {
|
|
return result;
|
|
}
|
|
const sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol)) : getReturnTypeOfSignature(source);
|
|
const targetTypePredicate = getTypePredicateOfSignature(target);
|
|
if (targetTypePredicate) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
if (sourceTypePredicate) {
|
|
result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes);
|
|
} else if (isIdentifierTypePredicate(targetTypePredicate)) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else {
|
|
result &= checkMode & 1 /* BivariantCallback */ && compareTypes(targetReturnType, sourceReturnType, false) || compareTypes(sourceReturnType, targetReturnType, reportErrors2);
|
|
if (!result && reportErrors2 && incompatibleErrorReporter) {
|
|
incompatibleErrorReporter(sourceReturnType, targetReturnType);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function compareTypePredicateRelatedTo(source, target, reportErrors2, errorReporter, compareTypes) {
|
|
if (source.kind !== target.kind) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (source.kind === 1 /* Identifier */ || source.kind === 3 /* AssertsIdentifier */) {
|
|
if (source.parameterIndex !== target.parameterIndex) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName);
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const related = source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type, reportErrors2) : 0 /* False */;
|
|
if (related === 0 /* False */ && reportErrors2) {
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return related;
|
|
}
|
|
function isImplementationCompatibleWithOverload(implementation, overload) {
|
|
const erasedSource = getErasedSignature(implementation);
|
|
const erasedTarget = getErasedSignature(overload);
|
|
const sourceReturnType = getReturnTypeOfSignature(erasedSource);
|
|
const targetReturnType = getReturnTypeOfSignature(erasedTarget);
|
|
if (targetReturnType === voidType || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation) || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) {
|
|
return isSignatureAssignableTo(erasedSource, erasedTarget, 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 /* Object */ ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) : type.flags & 67108864 /* NonPrimitive */ ? true : type.flags & 1048576 /* Union */ ? some(type.types, isEmptyObjectType) : type.flags & 2097152 /* Intersection */ ? every(type.types, isEmptyObjectType) : false;
|
|
}
|
|
function isEmptyAnonymousObjectType(type) {
|
|
return !!(getObjectFlags(type) & 16 /* Anonymous */ && (type.members && isEmptyResolvedType(type) || type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && getMembersOfSymbol(type.symbol).size === 0));
|
|
}
|
|
function isUnknownLikeUnionType(type) {
|
|
if (strictNullChecks && type.flags & 1048576 /* Union */) {
|
|
if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
|
|
const types = type.types;
|
|
type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ && types[1].flags & 65536 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
|
|
}
|
|
return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
|
|
}
|
|
return false;
|
|
}
|
|
function containsUndefinedType(type) {
|
|
return !!((type.flags & 1048576 /* Union */ ? type.types[0] : type).flags & 32768 /* Undefined */);
|
|
}
|
|
function isStringIndexSignatureOnlyType(type) {
|
|
return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || type.flags & 3145728 /* UnionOrIntersection */ && every(type.types, isStringIndexSignatureOnlyType) || false;
|
|
}
|
|
function isEnumTypeRelatedTo(source, target, errorReporter) {
|
|
const sourceSymbol = source.flags & 8 /* EnumMember */ ? getParentOfSymbol(source) : source;
|
|
const targetSymbol = target.flags & 8 /* EnumMember */ ? getParentOfSymbol(target) : target;
|
|
if (sourceSymbol === targetSymbol) {
|
|
return true;
|
|
}
|
|
if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
|
|
return false;
|
|
}
|
|
const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
|
|
const entry = enumRelation.get(id);
|
|
if (entry !== void 0 && !(!(entry & 4 /* Reported */) && entry & 2 /* Failed */ && errorReporter)) {
|
|
return !!(entry & 1 /* Succeeded */);
|
|
}
|
|
const targetEnumType = getTypeOfSymbol(targetSymbol);
|
|
for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
|
|
if (property.flags & 8 /* EnumMember */) {
|
|
const targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
|
|
if (!targetProperty || !(targetProperty.flags & 8 /* EnumMember */)) {
|
|
if (errorReporter) {
|
|
errorReporter(
|
|
Diagnostics.Property_0_is_missing_in_type_1,
|
|
symbolName(property),
|
|
typeToString(getDeclaredTypeOfSymbol(targetSymbol), void 0, 64 /* UseFullyQualifiedType */)
|
|
);
|
|
enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
|
|
} else {
|
|
enumRelation.set(id, 2 /* Failed */);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
enumRelation.set(id, 1 /* Succeeded */);
|
|
return true;
|
|
}
|
|
function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
|
|
const s = source.flags;
|
|
const t = target.flags;
|
|
if (t & 3 /* AnyOrUnknown */ || s & 131072 /* Never */ || source === wildcardType)
|
|
return true;
|
|
if (t & 131072 /* Never */)
|
|
return false;
|
|
if (s & 402653316 /* StringLike */ && t & 4 /* String */)
|
|
return true;
|
|
if (s & 128 /* StringLiteral */ && s & 1024 /* EnumLiteral */ && t & 128 /* StringLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value)
|
|
return true;
|
|
if (s & 296 /* NumberLike */ && t & 8 /* Number */)
|
|
return true;
|
|
if (s & 256 /* NumberLiteral */ && s & 1024 /* EnumLiteral */ && t & 256 /* NumberLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value)
|
|
return true;
|
|
if (s & 2112 /* BigIntLike */ && t & 64 /* BigInt */)
|
|
return true;
|
|
if (s & 528 /* BooleanLike */ && t & 16 /* Boolean */)
|
|
return true;
|
|
if (s & 12288 /* ESSymbolLike */ && t & 4096 /* ESSymbol */)
|
|
return true;
|
|
if (s & 32 /* Enum */ && t & 32 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
if (s & 1024 /* EnumLiteral */ && t & 1024 /* EnumLiteral */) {
|
|
if (s & 1048576 /* Union */ && t & 1048576 /* Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
}
|
|
if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */)))
|
|
return true;
|
|
if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
|
|
return true;
|
|
if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(getObjectFlags(source) & 8192 /* FreshLiteral */)))
|
|
return true;
|
|
if (relation === assignableRelation || relation === comparableRelation) {
|
|
if (s & 1 /* Any */)
|
|
return true;
|
|
if (s & 8 /* Number */ && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
|
|
return true;
|
|
if (s & 256 /* NumberLiteral */ && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */ && source.value === target.value))
|
|
return true;
|
|
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 /* Never */) && isSimpleTypeRelatedTo(target, source, relation) || isSimpleTypeRelatedTo(source, target, relation)) {
|
|
return true;
|
|
}
|
|
} else if (!((source.flags | target.flags) & (3145728 /* UnionOrIntersection */ | 8388608 /* IndexedAccess */ | 16777216 /* Conditional */ | 33554432 /* Substitution */))) {
|
|
if (source.flags !== target.flags)
|
|
return false;
|
|
if (source.flags & 67358815 /* Singleton */)
|
|
return true;
|
|
}
|
|
if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
|
|
const related = relation.get(getRelationKey(source, target, 0 /* None */, relation, false));
|
|
if (related !== void 0) {
|
|
return !!(related & 1 /* Succeeded */);
|
|
}
|
|
}
|
|
if (source.flags & 469499904 /* StructuredOrInstantiable */ || target.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
return checkTypeRelatedTo(source, target, relation, void 0);
|
|
}
|
|
return false;
|
|
}
|
|
function isIgnoredJsxProperty(source, sourceProp) {
|
|
return getObjectFlags(source) & 2048 /* JsxAttributes */ && isHyphenatedJsxName(sourceProp.escapedName);
|
|
}
|
|
function getNormalizedType(type, writing) {
|
|
while (true) {
|
|
const t = isFreshLiteralType(type) ? type.regularType : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
|
|
if (t === type)
|
|
return t;
|
|
type = t;
|
|
}
|
|
}
|
|
function getNormalizedUnionOrIntersectionType(type, writing) {
|
|
const reduced = getReducedType(type);
|
|
if (reduced !== type) {
|
|
return reduced;
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */ && some(type.types, isEmptyAnonymousObjectType)) {
|
|
const normalizedTypes = sameMap(type.types, (t) => getNormalizedType(t, writing));
|
|
if (normalizedTypes !== type.types) {
|
|
return getIntersectionType(normalizedTypes);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
|
|
var _a2;
|
|
let errorInfo;
|
|
let relatedInfo;
|
|
let maybeKeys;
|
|
let sourceStack;
|
|
let targetStack;
|
|
let maybeCount = 0;
|
|
let sourceDepth = 0;
|
|
let targetDepth = 0;
|
|
let expandingFlags = 0 /* None */;
|
|
let overflow = false;
|
|
let overrideNextErrorInfo = 0;
|
|
let lastSkippedInfo;
|
|
let incompatibleStack;
|
|
let inPropertyCheck = false;
|
|
Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
|
|
const result = isRelatedTo(source, target, 3 /* Both */, !!errorNode, headMessage);
|
|
if (incompatibleStack) {
|
|
reportIncompatibleStack();
|
|
}
|
|
if (overflow) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: sourceDepth, targetDepth });
|
|
const diag2 = error(errorNode || currentNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
|
|
if (errorOutputContainer) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
} else if (errorInfo) {
|
|
if (containingMessageChain) {
|
|
const chain = containingMessageChain();
|
|
if (chain) {
|
|
concatenateDiagnosticMessageChains(chain, errorInfo);
|
|
errorInfo = chain;
|
|
}
|
|
}
|
|
let relatedInformation;
|
|
if (headMessage && errorNode && !result && source.symbol) {
|
|
const links = getSymbolLinks(source.symbol);
|
|
if (links.originatingImport && !isImportCall(links.originatingImport)) {
|
|
const helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, void 0);
|
|
if (helpfulRetry) {
|
|
const diag3 = createDiagnosticForNode(links.originatingImport, 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 = append(relatedInformation, diag3);
|
|
}
|
|
}
|
|
}
|
|
const diag2 = createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(diag2, ...relatedInfo);
|
|
}
|
|
if (errorOutputContainer) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
if (!errorOutputContainer || !errorOutputContainer.skipLogging) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0 /* False */) {
|
|
Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error.");
|
|
}
|
|
return result !== 0 /* False */;
|
|
function resetErrorInfo(saved) {
|
|
errorInfo = saved.errorInfo;
|
|
lastSkippedInfo = saved.lastSkippedInfo;
|
|
incompatibleStack = saved.incompatibleStack;
|
|
overrideNextErrorInfo = saved.overrideNextErrorInfo;
|
|
relatedInfo = saved.relatedInfo;
|
|
}
|
|
function captureErrorCalculationState() {
|
|
return {
|
|
errorInfo,
|
|
lastSkippedInfo,
|
|
incompatibleStack: incompatibleStack == null ? void 0 : incompatibleStack.slice(),
|
|
overrideNextErrorInfo,
|
|
relatedInfo: relatedInfo == null ? void 0 : relatedInfo.slice()
|
|
};
|
|
}
|
|
function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
|
|
overrideNextErrorInfo++;
|
|
lastSkippedInfo = void 0;
|
|
(incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
|
|
}
|
|
function reportIncompatibleStack() {
|
|
const stack = incompatibleStack || [];
|
|
incompatibleStack = void 0;
|
|
const info = lastSkippedInfo;
|
|
lastSkippedInfo = void 0;
|
|
if (stack.length === 1) {
|
|
reportError(...stack[0]);
|
|
if (info) {
|
|
reportRelationError(void 0, ...info);
|
|
}
|
|
return;
|
|
}
|
|
let path = "";
|
|
const secondaryRootErrors = [];
|
|
while (stack.length) {
|
|
const [msg, ...args] = stack.pop();
|
|
switch (msg.code) {
|
|
case Diagnostics.Types_of_property_0_are_incompatible.code: {
|
|
if (path.indexOf("new ") === 0) {
|
|
path = `(${path})`;
|
|
}
|
|
const str = "" + args[0];
|
|
if (path.length === 0) {
|
|
path = `${str}`;
|
|
} else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
|
|
path = `${path}.${str}`;
|
|
} else if (str[0] === "[" && str[str.length - 1] === "]") {
|
|
path = `${path}${str}`;
|
|
} else {
|
|
path = `${path}[${str}]`;
|
|
}
|
|
break;
|
|
}
|
|
case Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code:
|
|
case Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
|
|
case Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
|
|
case Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
|
|
if (path.length === 0) {
|
|
let mappedMsg = msg;
|
|
if (msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
|
|
mappedMsg = Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
|
|
} else if (msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
|
|
mappedMsg = Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible;
|
|
}
|
|
secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]);
|
|
} else {
|
|
const prefix = msg.code === Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "new " : "";
|
|
const params = msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "" : "...";
|
|
path = `${prefix}${path}(${params})`;
|
|
}
|
|
break;
|
|
}
|
|
case Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target.code: {
|
|
secondaryRootErrors.unshift([Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, args[0], args[1]]);
|
|
break;
|
|
}
|
|
case Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target.code: {
|
|
secondaryRootErrors.unshift([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 Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
|
|
}
|
|
}
|
|
if (path) {
|
|
reportError(
|
|
path[path.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
|
|
path
|
|
);
|
|
} else {
|
|
secondaryRootErrors.shift();
|
|
}
|
|
for (const [msg, ...args] of secondaryRootErrors) {
|
|
const originalValue = msg.elidedInCompatabilityPyramid;
|
|
msg.elidedInCompatabilityPyramid = false;
|
|
reportError(msg, ...args);
|
|
msg.elidedInCompatabilityPyramid = originalValue;
|
|
}
|
|
if (info) {
|
|
reportRelationError(void 0, ...info);
|
|
}
|
|
}
|
|
function reportError(message, arg0, arg1, arg2, arg3) {
|
|
Debug.assert(!!errorNode);
|
|
if (incompatibleStack)
|
|
reportIncompatibleStack();
|
|
if (message.elidedInCompatabilityPyramid)
|
|
return;
|
|
errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function associateRelatedInfo(info) {
|
|
Debug.assert(!!errorInfo);
|
|
if (!relatedInfo) {
|
|
relatedInfo = [info];
|
|
} else {
|
|
relatedInfo.push(info);
|
|
}
|
|
}
|
|
function reportRelationError(message, source2, target2) {
|
|
if (incompatibleStack)
|
|
reportIncompatibleStack();
|
|
const [sourceType, targetType] = getTypeNamesForErrorDisplay(source2, target2);
|
|
let generalizedSource = source2;
|
|
let generalizedSourceType = sourceType;
|
|
if (isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) {
|
|
generalizedSource = getBaseTypeOfLiteralType(source2);
|
|
Debug.assert(!isTypeAssignableTo(generalizedSource, target2), "generalized source shouldn't be assignable");
|
|
generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource);
|
|
}
|
|
if (target2.flags & 262144 /* TypeParameter */ && target2 !== markerSuperTypeForCheck && target2 !== markerSubTypeForCheck) {
|
|
const constraint = getBaseConstraintOfType(target2);
|
|
let needsOriginalSource;
|
|
if (constraint && (isTypeAssignableTo(generalizedSource, constraint) || (needsOriginalSource = isTypeAssignableTo(source2, constraint)))) {
|
|
reportError(
|
|
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 = void 0;
|
|
reportError(
|
|
Diagnostics._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1,
|
|
targetType,
|
|
generalizedSourceType
|
|
);
|
|
}
|
|
}
|
|
if (!message) {
|
|
if (relation === comparableRelation) {
|
|
message = Diagnostics.Type_0_is_not_comparable_to_type_1;
|
|
} else if (sourceType === targetType) {
|
|
message = Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated;
|
|
} else if (exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source2, target2).length) {
|
|
message = 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 (source2.flags & 128 /* StringLiteral */ && target2.flags & 1048576 /* Union */) {
|
|
const suggestedType = getSuggestedTypeForNonexistentStringLiteralType(source2, target2);
|
|
if (suggestedType) {
|
|
reportError(Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2, generalizedSourceType, targetType, typeToString(suggestedType));
|
|
return;
|
|
}
|
|
}
|
|
message = Diagnostics.Type_0_is_not_assignable_to_type_1;
|
|
}
|
|
} else if (message === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 && exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source2, target2).length) {
|
|
message = 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(source2, target2) {
|
|
const sourceType = symbolValueDeclarationIsContextSensitive(source2.symbol) ? typeToString(source2, source2.symbol.valueDeclaration) : typeToString(source2);
|
|
const targetType = symbolValueDeclarationIsContextSensitive(target2.symbol) ? typeToString(target2, target2.symbol.valueDeclaration) : typeToString(target2);
|
|
if (globalStringType === source2 && stringType === target2 || globalNumberType === source2 && numberType === target2 || globalBooleanType === source2 && booleanType === target2 || getGlobalESSymbolType() === source2 && esSymbolType === target2) {
|
|
reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
|
|
}
|
|
}
|
|
function tryElaborateArrayLikeErrors(source2, target2, reportErrors2) {
|
|
if (isTupleType(source2)) {
|
|
if (source2.target.readonly && isMutableArrayOrTuple(target2)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return false;
|
|
}
|
|
return isArrayOrTupleType(target2);
|
|
}
|
|
if (isReadonlyArrayType(source2) && isMutableArrayOrTuple(target2)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return false;
|
|
}
|
|
if (isTupleType(target2)) {
|
|
return isArrayType(source2);
|
|
}
|
|
return true;
|
|
}
|
|
function isRelatedToWorker(source2, target2, reportErrors2) {
|
|
return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
|
|
}
|
|
function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
|
|
if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 131068 /* Primitive */) {
|
|
if (relation === comparableRelation && !(originalTarget.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(originalTarget, originalSource, relation) || isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors2 ? reportError : void 0)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const source2 = getNormalizedType(originalSource, false);
|
|
let target2 = getNormalizedType(originalTarget, true);
|
|
if (source2 === target2)
|
|
return -1 /* True */;
|
|
if (relation === identityRelation) {
|
|
if (source2.flags !== target2.flags)
|
|
return 0 /* False */;
|
|
if (source2.flags & 67358815 /* Singleton */)
|
|
return -1 /* True */;
|
|
traceUnionsOrIntersectionsTooLarge(source2, target2);
|
|
return recursiveTypeRelatedTo(source2, target2, false, 0 /* None */, recursionFlags);
|
|
}
|
|
if (source2.flags & 262144 /* TypeParameter */ && getConstraintOfType(source2) === target2) {
|
|
return -1 /* True */;
|
|
}
|
|
if (source2.flags & 470302716 /* DefinitelyNonNullable */ && target2.flags & 1048576 /* Union */) {
|
|
const types = target2.types;
|
|
const candidate = types.length === 2 && types[0].flags & 98304 /* Nullable */ ? types[1] : types.length === 3 && types[0].flags & 98304 /* Nullable */ && types[1].flags & 98304 /* Nullable */ ? types[2] : void 0;
|
|
if (candidate && !(candidate.flags & 98304 /* Nullable */)) {
|
|
target2 = getNormalizedType(candidate, true);
|
|
if (source2 === target2)
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
if (relation === comparableRelation && !(target2.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target2, source2, relation) || isSimpleTypeRelatedTo(source2, target2, relation, reportErrors2 ? reportError : void 0))
|
|
return -1 /* True */;
|
|
if (source2.flags & 469499904 /* StructuredOrInstantiable */ || target2.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
const isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */);
|
|
if (isPerformingExcessPropertyChecks) {
|
|
if (hasExcessProperties(source2, target2, reportErrors2)) {
|
|
if (reportErrors2) {
|
|
reportRelationError(headMessage2, source2, originalTarget.aliasSymbol ? originalTarget : target2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures2(source2));
|
|
const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
|
|
if (isPerformingCommonPropertyChecks && !hasCommonProperties(source2, target2, isComparingJsxAttributes)) {
|
|
if (reportErrors2) {
|
|
const sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source2);
|
|
const targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target2);
|
|
const calls = getSignaturesOfType(source2, 0 /* Call */);
|
|
const constructs = getSignaturesOfType(source2, 1 /* Construct */);
|
|
if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target2, 1 /* Source */, false) || constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target2, 1 /* Source */, false)) {
|
|
reportError(Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
|
|
} else {
|
|
reportError(Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
traceUnionsOrIntersectionsTooLarge(source2, target2);
|
|
const skipCaching = source2.flags & 1048576 /* Union */ && source2.types.length < 4 && !(target2.flags & 1048576 /* Union */) || target2.flags & 1048576 /* Union */ && target2.types.length < 4 && !(source2.flags & 469499904 /* StructuredOrInstantiable */);
|
|
const result2 = skipCaching ? unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState) : recursiveTypeRelatedTo(source2, target2, reportErrors2, intersectionState, recursionFlags);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorResults(originalSource, originalTarget, source2, target2, headMessage2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function reportErrorResults(originalSource, originalTarget, source2, target2, headMessage2) {
|
|
var _a3, _b;
|
|
const sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
|
|
const targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
|
|
source2 = originalSource.aliasSymbol || sourceHasBase ? originalSource : source2;
|
|
target2 = originalTarget.aliasSymbol || targetHasBase ? originalTarget : target2;
|
|
let maybeSuppress = overrideNextErrorInfo > 0;
|
|
if (maybeSuppress) {
|
|
overrideNextErrorInfo--;
|
|
}
|
|
if (source2.flags & 524288 /* Object */ && target2.flags & 524288 /* Object */) {
|
|
const currentError = errorInfo;
|
|
tryElaborateArrayLikeErrors(source2, target2, true);
|
|
if (errorInfo !== currentError) {
|
|
maybeSuppress = !!errorInfo;
|
|
}
|
|
}
|
|
if (source2.flags & 524288 /* Object */ && target2.flags & 131068 /* Primitive */) {
|
|
tryElaborateErrorsForPrimitivesAndObjects(source2, target2);
|
|
} else if (source2.symbol && source2.flags & 524288 /* Object */ && globalObjectType === source2) {
|
|
reportError(Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
|
|
} else if (getObjectFlags(source2) & 2048 /* JsxAttributes */ && target2.flags & 2097152 /* Intersection */) {
|
|
const targetTypes = target2.types;
|
|
const intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
|
|
const intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
|
|
if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) && (contains(targetTypes, intrinsicAttributes) || contains(targetTypes, intrinsicClassAttributes))) {
|
|
return;
|
|
}
|
|
} else {
|
|
errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
|
|
}
|
|
if (!headMessage2 && maybeSuppress) {
|
|
lastSkippedInfo = [source2, target2];
|
|
return;
|
|
}
|
|
reportRelationError(headMessage2, source2, target2);
|
|
if (source2.flags & 262144 /* TypeParameter */ && ((_b = (_a3 = source2.symbol) == null ? void 0 : _a3.declarations) == null ? void 0 : _b[0]) && !getConstraintOfType(source2)) {
|
|
const syntheticParam = cloneTypeParameter(source2);
|
|
syntheticParam.constraint = instantiateType(target2, makeUnaryTypeMapper(source2, syntheticParam));
|
|
if (hasNonCircularBaseConstraint(syntheticParam)) {
|
|
const targetConstraintString = typeToString(target2, source2.symbol.declarations[0]);
|
|
associateRelatedInfo(createDiagnosticForNode(source2.symbol.declarations[0], Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
|
|
}
|
|
}
|
|
}
|
|
function traceUnionsOrIntersectionsTooLarge(source2, target2) {
|
|
if (!tracing) {
|
|
return;
|
|
}
|
|
if (source2.flags & 3145728 /* UnionOrIntersection */ && target2.flags & 3145728 /* UnionOrIntersection */) {
|
|
const sourceUnionOrIntersection = source2;
|
|
const targetUnionOrIntersection = target2;
|
|
if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 32768 /* PrimitiveUnion */) {
|
|
return;
|
|
}
|
|
const sourceSize = sourceUnionOrIntersection.types.length;
|
|
const targetSize = targetUnionOrIntersection.types.length;
|
|
if (sourceSize * targetSize > 1e6) {
|
|
tracing.instant(tracing.Phase.CheckTypes, "traceUnionsOrIntersectionsTooLarge_DepthLimit", {
|
|
sourceId: source2.id,
|
|
sourceSize,
|
|
targetId: target2.id,
|
|
targetSize,
|
|
pos: errorNode == null ? void 0 : errorNode.pos,
|
|
end: errorNode == null ? void 0 : errorNode.end
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfPropertyInTypes(types, name) {
|
|
const appendPropType = (propTypes, type) => {
|
|
var _a3;
|
|
type = getApparentType(type);
|
|
const prop = type.flags & 3145728 /* UnionOrIntersection */ ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name);
|
|
const propType = prop && getTypeOfSymbol(prop) || ((_a3 = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a3.type) || undefinedType;
|
|
return append(propTypes, propType);
|
|
};
|
|
return getUnionType(reduceLeft(types, appendPropType, void 0) || emptyArray);
|
|
}
|
|
function hasExcessProperties(source2, target2, reportErrors2) {
|
|
var _a3;
|
|
if (!isExcessPropertyCheckTarget(target2) || !noImplicitAny && getObjectFlags(target2) & 4096 /* JSLiteral */) {
|
|
return false;
|
|
}
|
|
const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
|
|
if ((relation === assignableRelation || relation === comparableRelation) && (isTypeSubsetOf(globalObjectType, target2) || !isComparingJsxAttributes && isEmptyObjectType(target2))) {
|
|
return false;
|
|
}
|
|
let reducedTarget = target2;
|
|
let checkTypes;
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
reducedTarget = findMatchingDiscriminantType(source2, target2, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target2);
|
|
checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
|
|
}
|
|
for (const prop of getPropertiesOfType(source2)) {
|
|
if (shouldCheckAsExcessProperty(prop, source2.symbol) && !isIgnoredJsxProperty(source2, prop)) {
|
|
if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
|
|
if (reportErrors2) {
|
|
const errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget);
|
|
if (!errorNode)
|
|
return Debug.fail();
|
|
if (isJsxAttributes(errorNode) || isJsxOpeningLikeElement(errorNode) || isJsxOpeningLikeElement(errorNode.parent)) {
|
|
if (prop.valueDeclaration && isJsxAttribute(prop.valueDeclaration) && getSourceFileOfNode(errorNode) === getSourceFileOfNode(prop.valueDeclaration.name)) {
|
|
errorNode = prop.valueDeclaration.name;
|
|
}
|
|
const propName = symbolToString(prop);
|
|
const suggestionSymbol = getSuggestedSymbolForNonexistentJSXAttribute(propName, errorTarget);
|
|
const suggestion = suggestionSymbol ? symbolToString(suggestionSymbol) : void 0;
|
|
if (suggestion) {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(errorTarget), suggestion);
|
|
} else {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, propName, typeToString(errorTarget));
|
|
}
|
|
} else {
|
|
const objectLiteralDeclaration = ((_a3 = source2.symbol) == null ? void 0 : _a3.declarations) && firstOrUndefined(source2.symbol.declarations);
|
|
let suggestion;
|
|
if (prop.valueDeclaration && findAncestor(prop.valueDeclaration, (d) => d === objectLiteralDeclaration) && getSourceFileOfNode(objectLiteralDeclaration) === getSourceFileOfNode(errorNode)) {
|
|
const propDeclaration = prop.valueDeclaration;
|
|
Debug.assertNode(propDeclaration, isObjectLiteralElementLike);
|
|
errorNode = propDeclaration;
|
|
const name = propDeclaration.name;
|
|
if (isIdentifier(name)) {
|
|
suggestion = getSuggestionForNonexistentProperty(name, errorTarget);
|
|
}
|
|
}
|
|
if (suggestion !== void 0) {
|
|
reportError(
|
|
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(
|
|
Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
|
|
symbolToString(prop),
|
|
typeToString(errorTarget)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), 3 /* Both */, reportErrors2)) {
|
|
if (reportErrors2) {
|
|
reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function shouldCheckAsExcessProperty(prop, container) {
|
|
return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
|
|
}
|
|
function unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState) {
|
|
if (source2.flags & 1048576 /* Union */) {
|
|
return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState);
|
|
}
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */) && !(target2.flags & 131068 /* Primitive */));
|
|
}
|
|
if (target2.flags & 2097152 /* Intersection */) {
|
|
return typeRelatedToEachType(source2, target2, reportErrors2, 2 /* Target */);
|
|
}
|
|
if (relation === comparableRelation && target2.flags & 131068 /* Primitive */) {
|
|
const constraints = sameMap(source2.types, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(t) || unknownType : t);
|
|
if (constraints !== source2.types) {
|
|
source2 = getIntersectionType(constraints);
|
|
if (source2.flags & 131072 /* Never */) {
|
|
return 0 /* False */;
|
|
}
|
|
if (!(source2.flags & 2097152 /* Intersection */)) {
|
|
return isRelatedTo(source2, target2, 1 /* Source */, false) || isRelatedTo(target2, source2, 1 /* Source */, false);
|
|
}
|
|
}
|
|
}
|
|
return someTypeRelatedToType(source2, target2, false, 1 /* Source */);
|
|
}
|
|
function eachTypeRelatedToSomeType(source2, target2) {
|
|
let result2 = -1 /* True */;
|
|
const sourceTypes = source2.types;
|
|
for (const sourceType of sourceTypes) {
|
|
const related = typeRelatedToSomeType(sourceType, target2, false);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeRelatedToSomeType(source2, target2, reportErrors2) {
|
|
const targetTypes = target2.types;
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
if (containsType(targetTypes, source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const match = getMatchingUnionConstituentForType(target2, source2);
|
|
if (match) {
|
|
const related = isRelatedTo(source2, match, 2 /* Target */, false);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
}
|
|
for (const type of targetTypes) {
|
|
const related = isRelatedTo(source2, type, 2 /* Target */, false);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
const bestMatchingType = getBestMatchingType(source2, target2, isRelatedTo);
|
|
if (bestMatchingType) {
|
|
isRelatedTo(source2, bestMatchingType, 2 /* Target */, true);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function typeRelatedToEachType(source2, target2, reportErrors2, intersectionState) {
|
|
let result2 = -1 /* True */;
|
|
const targetTypes = target2.types;
|
|
for (const targetType of targetTypes) {
|
|
const related = isRelatedTo(source2, targetType, 2 /* Target */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function someTypeRelatedToType(source2, target2, reportErrors2, intersectionState) {
|
|
const sourceTypes = source2.types;
|
|
if (source2.flags & 1048576 /* Union */ && containsType(sourceTypes, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const len = sourceTypes.length;
|
|
for (let i = 0; i < len; i++) {
|
|
const related = isRelatedTo(sourceTypes[i], target2, 1 /* Source */, reportErrors2 && i === len - 1, void 0, intersectionState);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function getUndefinedStrippedTargetIfNeeded(source2, target2) {
|
|
if (source2.flags & 1048576 /* Union */ && target2.flags & 1048576 /* Union */ && !(source2.types[0].flags & 32768 /* Undefined */) && target2.types[0].flags & 32768 /* Undefined */) {
|
|
return extractTypesOfKind(target2, ~32768 /* Undefined */);
|
|
}
|
|
return target2;
|
|
}
|
|
function eachTypeRelatedToType(source2, target2, reportErrors2, intersectionState) {
|
|
let result2 = -1 /* True */;
|
|
const sourceTypes = source2.types;
|
|
const undefinedStrippedTarget = getUndefinedStrippedTargetIfNeeded(source2, target2);
|
|
for (let i = 0; i < sourceTypes.length; i++) {
|
|
const sourceType = sourceTypes[i];
|
|
if (undefinedStrippedTarget.flags & 1048576 /* Union */ && sourceTypes.length >= undefinedStrippedTarget.types.length && sourceTypes.length % undefinedStrippedTarget.types.length === 0) {
|
|
const related2 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], 3 /* Both */, false, void 0, intersectionState);
|
|
if (related2) {
|
|
result2 &= related2;
|
|
continue;
|
|
}
|
|
}
|
|
const related = isRelatedTo(sourceType, target2, 1 /* Source */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeArgumentsRelatedTo(sources = emptyArray, targets = emptyArray, variances = emptyArray, reportErrors2, intersectionState) {
|
|
if (sources.length !== targets.length && relation === identityRelation) {
|
|
return 0 /* False */;
|
|
}
|
|
const length2 = sources.length <= targets.length ? sources.length : targets.length;
|
|
let result2 = -1 /* True */;
|
|
for (let i = 0; i < length2; i++) {
|
|
const varianceFlags = i < variances.length ? variances[i] : 1 /* Covariant */;
|
|
const variance = varianceFlags & 7 /* VarianceMask */;
|
|
if (variance !== 4 /* Independent */) {
|
|
const s = sources[i];
|
|
const t = targets[i];
|
|
let related = -1 /* True */;
|
|
if (varianceFlags & 8 /* Unmeasurable */) {
|
|
related = relation === identityRelation ? isRelatedTo(s, t, 3 /* Both */, false) : compareTypesIdentical(s, t);
|
|
} else if (variance === 1 /* Covariant */) {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
} else if (variance === 2 /* Contravariant */) {
|
|
related = isRelatedTo(t, s, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
} else if (variance === 3 /* Bivariant */) {
|
|
related = isRelatedTo(t, s, 3 /* Both */, false);
|
|
if (!related) {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
} else {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
if (related) {
|
|
related &= isRelatedTo(t, s, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
}
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function recursiveTypeRelatedTo(source2, target2, reportErrors2, intersectionState, recursionFlags) {
|
|
var _a3, _b, _c;
|
|
if (overflow) {
|
|
return 0 /* False */;
|
|
}
|
|
const id = getRelationKey(source2, target2, intersectionState, relation, false);
|
|
const entry = relation.get(id);
|
|
if (entry !== void 0) {
|
|
if (reportErrors2 && entry & 2 /* Failed */ && !(entry & 4 /* Reported */)) {
|
|
} else {
|
|
if (outofbandVarianceMarkerHandler) {
|
|
const saved = entry & 24 /* ReportsMask */;
|
|
if (saved & 8 /* ReportsUnmeasurable */) {
|
|
instantiateType(source2, reportUnmeasurableMapper);
|
|
}
|
|
if (saved & 16 /* ReportsUnreliable */) {
|
|
instantiateType(source2, reportUnreliableMapper);
|
|
}
|
|
}
|
|
return entry & 1 /* Succeeded */ ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
}
|
|
if (!maybeKeys) {
|
|
maybeKeys = [];
|
|
sourceStack = [];
|
|
targetStack = [];
|
|
} else {
|
|
const broadestEquivalentId = id.startsWith("*") ? getRelationKey(source2, target2, intersectionState, relation, true) : void 0;
|
|
for (let i = 0; i < maybeCount; i++) {
|
|
if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
}
|
|
if (sourceDepth === 100 || targetDepth === 100) {
|
|
overflow = true;
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const maybeStart = maybeCount;
|
|
maybeKeys[maybeCount] = id;
|
|
maybeCount++;
|
|
const saveExpandingFlags = expandingFlags;
|
|
if (recursionFlags & 1 /* Source */) {
|
|
sourceStack[sourceDepth] = source2;
|
|
sourceDepth++;
|
|
if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source2, sourceStack, sourceDepth))
|
|
expandingFlags |= 1 /* Source */;
|
|
}
|
|
if (recursionFlags & 2 /* Target */) {
|
|
targetStack[targetDepth] = target2;
|
|
targetDepth++;
|
|
if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target2, targetStack, targetDepth))
|
|
expandingFlags |= 2 /* Target */;
|
|
}
|
|
let originalHandler;
|
|
let propagatingVarianceFlags = 0;
|
|
if (outofbandVarianceMarkerHandler) {
|
|
originalHandler = outofbandVarianceMarkerHandler;
|
|
outofbandVarianceMarkerHandler = (onlyUnreliable) => {
|
|
propagatingVarianceFlags |= onlyUnreliable ? 16 /* ReportsUnreliable */ : 8 /* ReportsUnmeasurable */;
|
|
return originalHandler(onlyUnreliable);
|
|
};
|
|
}
|
|
let result2;
|
|
if (expandingFlags === 3 /* Both */) {
|
|
(_a3 = tracing) == null ? void 0 : _a3.instant(tracing.Phase.CheckTypes, "recursiveTypeRelatedTo_DepthLimit", {
|
|
sourceId: source2.id,
|
|
sourceIdStack: sourceStack.map((t) => t.id),
|
|
targetId: target2.id,
|
|
targetIdStack: targetStack.map((t) => t.id),
|
|
depth: sourceDepth,
|
|
targetDepth
|
|
});
|
|
result2 = 3 /* Maybe */;
|
|
} else {
|
|
(_b = tracing) == null ? void 0 : _b.push(tracing.Phase.CheckTypes, "structuredTypeRelatedTo", { sourceId: source2.id, targetId: target2.id });
|
|
result2 = structuredTypeRelatedTo(source2, target2, reportErrors2, intersectionState);
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
}
|
|
if (outofbandVarianceMarkerHandler) {
|
|
outofbandVarianceMarkerHandler = originalHandler;
|
|
}
|
|
if (recursionFlags & 1 /* Source */) {
|
|
sourceDepth--;
|
|
}
|
|
if (recursionFlags & 2 /* Target */) {
|
|
targetDepth--;
|
|
}
|
|
expandingFlags = saveExpandingFlags;
|
|
if (result2) {
|
|
if (result2 === -1 /* True */ || sourceDepth === 0 && targetDepth === 0) {
|
|
if (result2 === -1 /* True */ || result2 === 3 /* Maybe */) {
|
|
for (let i = maybeStart; i < maybeCount; i++) {
|
|
relation.set(maybeKeys[i], 1 /* Succeeded */ | propagatingVarianceFlags);
|
|
}
|
|
}
|
|
maybeCount = maybeStart;
|
|
}
|
|
} else {
|
|
relation.set(id, (reportErrors2 ? 4 /* Reported */ : 0) | 2 /* Failed */ | propagatingVarianceFlags);
|
|
maybeCount = maybeStart;
|
|
}
|
|
return result2;
|
|
}
|
|
function structuredTypeRelatedTo(source2, target2, reportErrors2, intersectionState) {
|
|
const saveErrorInfo = captureErrorCalculationState();
|
|
let result2 = structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo);
|
|
if (relation !== identityRelation) {
|
|
if (!result2 && (source2.flags & 2097152 /* Intersection */ || source2.flags & 262144 /* TypeParameter */ && target2.flags & 1048576 /* Union */)) {
|
|
const constraint = getEffectiveConstraintOfIntersection(source2.flags & 2097152 /* Intersection */ ? source2.types : [source2], !!(target2.flags & 1048576 /* Union */));
|
|
if (constraint && everyType(constraint, (c) => c !== source2)) {
|
|
result2 = isRelatedTo(constraint, target2, 1 /* Source */, false, void 0, intersectionState);
|
|
}
|
|
}
|
|
if (result2 && !inPropertyCheck && (target2.flags & 2097152 /* Intersection */ && !isGenericObjectType(target2) && source2.flags & (524288 /* Object */ | 2097152 /* Intersection */) || isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */)))) {
|
|
inPropertyCheck = true;
|
|
result2 &= propertiesRelatedTo(source2, target2, reportErrors2, void 0, 0 /* None */);
|
|
inPropertyCheck = false;
|
|
}
|
|
}
|
|
if (result2) {
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
return result2;
|
|
}
|
|
function structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo) {
|
|
let result2;
|
|
let originalErrorInfo;
|
|
let varianceCheckFailed = false;
|
|
let sourceFlags = source2.flags;
|
|
const targetFlags = target2.flags;
|
|
if (relation === identityRelation) {
|
|
if (sourceFlags & 3145728 /* UnionOrIntersection */) {
|
|
let result3 = eachTypeRelatedToSomeType(source2, target2);
|
|
if (result3) {
|
|
result3 &= eachTypeRelatedToSomeType(target2, source2);
|
|
}
|
|
return result3;
|
|
}
|
|
if (sourceFlags & 4194304 /* Index */) {
|
|
return isRelatedTo(source2.type, target2.type, 3 /* Both */, false);
|
|
}
|
|
if (sourceFlags & 8388608 /* IndexedAccess */) {
|
|
if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 16777216 /* Conditional */) {
|
|
if (source2.root.isDistributive === target2.root.isDistributive) {
|
|
if (result2 = isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.extendsType, target2.extendsType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(getTrueTypeFromConditionalType(source2), getTrueTypeFromConditionalType(target2), 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 33554432 /* Substitution */) {
|
|
if (result2 = isRelatedTo(source2.baseType, target2.baseType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.constraint, target2.constraint, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (!(sourceFlags & 524288 /* Object */)) {
|
|
return 0 /* False */;
|
|
}
|
|
} else if (sourceFlags & 3145728 /* UnionOrIntersection */ || targetFlags & 3145728 /* UnionOrIntersection */) {
|
|
if (result2 = unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (!(sourceFlags & 465829888 /* Instantiable */ || sourceFlags & 524288 /* Object */ && targetFlags & 1048576 /* Union */ || sourceFlags & 2097152 /* Intersection */ && targetFlags & (524288 /* Object */ | 1048576 /* Union */ | 465829888 /* Instantiable */))) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 16777216 /* Conditional */) && source2.aliasSymbol && source2.aliasTypeArguments && source2.aliasSymbol === target2.aliasSymbol && !(isMarkerType(source2) || isMarkerType(target2))) {
|
|
const variances = getAliasVariances(source2.aliasSymbol);
|
|
if (variances === emptyArray) {
|
|
return 1 /* Unknown */;
|
|
}
|
|
const varianceResult = relateVariances(source2.aliasTypeArguments, target2.aliasTypeArguments, variances, intersectionState);
|
|
if (varianceResult !== void 0) {
|
|
return varianceResult;
|
|
}
|
|
}
|
|
if (isSingleElementGenericTupleType(source2) && !source2.target.readonly && (result2 = isRelatedTo(getTypeArguments(source2)[0], target2, 1 /* Source */)) || isSingleElementGenericTupleType(target2) && (target2.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source2) || source2)) && (result2 = isRelatedTo(source2, getTypeArguments(target2)[0], 2 /* Target */))) {
|
|
return result2;
|
|
}
|
|
if (targetFlags & 262144 /* TypeParameter */) {
|
|
if (getObjectFlags(source2) & 32 /* Mapped */ && !source2.declaration.nameType && isRelatedTo(getIndexType(target2), getConstraintTypeFromMappedType(source2), 3 /* Both */)) {
|
|
if (!(getMappedTypeModifiers(source2) & 4 /* IncludeOptional */)) {
|
|
const templateType = getTemplateTypeFromMappedType(source2);
|
|
const indexedAccessType = getIndexedAccessType(target2, getTypeParameterFromMappedType(source2));
|
|
if (result2 = isRelatedTo(templateType, indexedAccessType, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (relation === comparableRelation && sourceFlags & 262144 /* TypeParameter */) {
|
|
let constraint = getConstraintOfTypeParameter(source2);
|
|
if (constraint && hasNonCircularBaseConstraint(source2)) {
|
|
while (constraint && someType(constraint, (c) => !!(c.flags & 262144 /* TypeParameter */))) {
|
|
if (result2 = isRelatedTo(constraint, target2, 1 /* Source */, false)) {
|
|
return result2;
|
|
}
|
|
constraint = getConstraintOfTypeParameter(constraint);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (targetFlags & 4194304 /* Index */) {
|
|
const targetType = target2.type;
|
|
if (sourceFlags & 4194304 /* Index */) {
|
|
if (result2 = isRelatedTo(targetType, source2.type, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (isTupleType(targetType)) {
|
|
if (result2 = isRelatedTo(source2, getKnownKeysOfTupleType(targetType), 2 /* Target */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const constraint = getSimplifiedTypeOrConstraint(targetType);
|
|
if (constraint) {
|
|
if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
|
|
return -1 /* True */;
|
|
}
|
|
} else if (isGenericMappedType(targetType)) {
|
|
const nameType = getNameTypeFromMappedType(targetType);
|
|
const constraintType = getConstraintTypeFromMappedType(targetType);
|
|
let targetKeys;
|
|
if (nameType && isMappedTypeWithKeyofConstraintDeclaration(targetType)) {
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
|
|
const mappedKeys = [];
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
|
|
modifiersType,
|
|
8576 /* StringOrNumberLiteralOrUnique */,
|
|
false,
|
|
(t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
|
|
);
|
|
targetKeys = getUnionType([...mappedKeys, nameType]);
|
|
} else {
|
|
targetKeys = nameType || constraintType;
|
|
}
|
|
if (isRelatedTo(source2, targetKeys, 2 /* Target */, reportErrors2) === -1 /* True */) {
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
}
|
|
} else if (targetFlags & 8388608 /* IndexedAccess */) {
|
|
if (sourceFlags & 8388608 /* IndexedAccess */) {
|
|
if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
|
|
result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
|
|
}
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
if (reportErrors2) {
|
|
originalErrorInfo = errorInfo;
|
|
}
|
|
}
|
|
if (relation === assignableRelation || relation === comparableRelation) {
|
|
const objectType = target2.objectType;
|
|
const indexType = target2.indexType;
|
|
const baseObjectType = getBaseConstraintOfType(objectType) || objectType;
|
|
const baseIndexType = getBaseConstraintOfType(indexType) || indexType;
|
|
if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) {
|
|
const accessFlags = 4 /* Writing */ | (baseObjectType !== objectType ? 2 /* NoIndexSignatures */ : 0);
|
|
const constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, accessFlags);
|
|
if (constraint) {
|
|
if (reportErrors2 && originalErrorInfo) {
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
if (result2 = isRelatedTo(source2, constraint, 2 /* Target */, reportErrors2, void 0, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (reportErrors2 && originalErrorInfo && errorInfo) {
|
|
errorInfo = countMessageChainBreadth([originalErrorInfo]) <= countMessageChainBreadth([errorInfo]) ? originalErrorInfo : errorInfo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
originalErrorInfo = void 0;
|
|
}
|
|
} else if (isGenericMappedType(target2) && relation !== identityRelation) {
|
|
const keysRemapped = !!target2.declaration.nameType;
|
|
const templateType = getTemplateTypeFromMappedType(target2);
|
|
const modifiers = getMappedTypeModifiers(target2);
|
|
if (!(modifiers & 8 /* ExcludeOptional */)) {
|
|
if (!keysRemapped && templateType.flags & 8388608 /* IndexedAccess */ && templateType.objectType === source2 && templateType.indexType === getTypeParameterFromMappedType(target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (!isGenericMappedType(source2)) {
|
|
const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
|
|
const sourceKeys = getIndexType(source2, void 0, true);
|
|
const includeOptional = modifiers & 4 /* IncludeOptional */;
|
|
const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
|
|
if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
|
|
const templateType2 = getTemplateTypeFromMappedType(target2);
|
|
const typeParameter = getTypeParameterFromMappedType(target2);
|
|
const nonNullComponent = extractTypesOfKind(templateType2, ~98304 /* Nullable */);
|
|
if (!keysRemapped && nonNullComponent.flags & 8388608 /* IndexedAccess */ && nonNullComponent.indexType === typeParameter) {
|
|
if (result2 = isRelatedTo(source2, nonNullComponent.objectType, 2 /* Target */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const indexingType = keysRemapped ? filteredByApplicability || targetKeys : filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter;
|
|
const indexedAccessType = getIndexedAccessType(source2, indexingType);
|
|
if (result2 = isRelatedTo(indexedAccessType, templateType2, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
originalErrorInfo = errorInfo;
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
}
|
|
} else if (targetFlags & 16777216 /* Conditional */) {
|
|
if (isDeeplyNestedType(target2, targetStack, targetDepth, 10)) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
const c = target2;
|
|
if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
|
|
const skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
|
|
const skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
|
|
if (result2 = skipTrue ? -1 /* True */ : isRelatedTo(source2, getTrueTypeFromConditionalType(c), 2 /* Target */, false, void 0, intersectionState)) {
|
|
result2 &= skipFalse ? -1 /* True */ : isRelatedTo(source2, getFalseTypeFromConditionalType(c), 2 /* Target */, false, void 0, intersectionState);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
} else if (targetFlags & 134217728 /* TemplateLiteral */) {
|
|
if (sourceFlags & 134217728 /* TemplateLiteral */) {
|
|
if (relation === comparableRelation) {
|
|
return templateLiteralTypesDefinitelyUnrelated(source2, target2) ? 0 /* False */ : -1 /* True */;
|
|
}
|
|
instantiateType(source2, reportUnreliableMapper);
|
|
}
|
|
if (isTypeMatchedByTemplateLiteralType(source2, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
} else if (target2.flags & 268435456 /* StringMapping */) {
|
|
if (!(source2.flags & 268435456 /* StringMapping */)) {
|
|
if (isMemberOfStringMapping(source2, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 8650752 /* TypeVariable */) {
|
|
if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
|
|
const constraint = getConstraintOfType(source2) || unknownType;
|
|
if (result2 = isRelatedTo(constraint, target2, 1 /* Source */, false, void 0, intersectionState)) {
|
|
return result2;
|
|
} else if (result2 = isRelatedTo(getTypeWithThisArgument(constraint, source2), target2, 1 /* Source */, reportErrors2 && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), void 0, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (isMappedTypeGenericIndexedAccess(source2)) {
|
|
const indexConstraint = getConstraintOfType(source2.indexType);
|
|
if (indexConstraint) {
|
|
if (result2 = isRelatedTo(getIndexedAccessType(source2.objectType, indexConstraint), target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (sourceFlags & 4194304 /* Index */) {
|
|
if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
|
|
if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
|
|
const constraint = getBaseConstraintOfType(source2);
|
|
if (constraint && constraint !== source2 && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else if (sourceFlags & 268435456 /* StringMapping */) {
|
|
if (targetFlags & 268435456 /* StringMapping */) {
|
|
if (source2.symbol !== target2.symbol) {
|
|
return 0 /* False */;
|
|
}
|
|
if (result2 = isRelatedTo(source2.type, target2.type, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const constraint = getBaseConstraintOfType(source2);
|
|
if (constraint && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else if (sourceFlags & 16777216 /* Conditional */) {
|
|
if (isDeeplyNestedType(source2, sourceStack, sourceDepth, 10)) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
if (targetFlags & 16777216 /* Conditional */) {
|
|
const sourceParams = source2.root.inferTypeParameters;
|
|
let sourceExtends = source2.extendsType;
|
|
let mapper;
|
|
if (sourceParams) {
|
|
const ctx = createInferenceContext(sourceParams, void 0, 0 /* None */, isRelatedToWorker);
|
|
inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
|
|
sourceExtends = instantiateType(sourceExtends, ctx.mapper);
|
|
mapper = ctx.mapper;
|
|
}
|
|
if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
|
|
if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
|
|
result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), 3 /* Both */, reportErrors2);
|
|
}
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else {
|
|
const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
|
|
if (distributiveConstraint) {
|
|
if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
|
|
if (defaultConstraint) {
|
|
if (result2 = isRelatedTo(defaultConstraint, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else {
|
|
if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (isGenericMappedType(target2)) {
|
|
if (isGenericMappedType(source2)) {
|
|
if (result2 = mappedTypeRelatedTo(source2, target2, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
|
|
if (relation !== identityRelation) {
|
|
source2 = getApparentType(source2);
|
|
sourceFlags = source2.flags;
|
|
} else if (isGenericMappedType(source2)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (getObjectFlags(source2) & 4 /* Reference */ && getObjectFlags(target2) & 4 /* Reference */ && source2.target === target2.target && !isTupleType(source2) && !(isMarkerType(source2) || isMarkerType(target2))) {
|
|
if (isEmptyArrayLiteralType(source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const variances = getVariances(source2.target);
|
|
if (variances === emptyArray) {
|
|
return 1 /* Unknown */;
|
|
}
|
|
const varianceResult = relateVariances(getTypeArguments(source2), getTypeArguments(target2), variances, intersectionState);
|
|
if (varianceResult !== void 0) {
|
|
return varianceResult;
|
|
}
|
|
} else if (isReadonlyArrayType(target2) ? isArrayOrTupleType(source2) : isArrayType(target2) && isTupleType(source2) && !source2.target.readonly) {
|
|
if (relation !== identityRelation) {
|
|
return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, 3 /* Both */, reportErrors2);
|
|
} else {
|
|
return 0 /* False */;
|
|
}
|
|
} else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 524288 /* Object */) {
|
|
const reportStructuralErrors = reportErrors2 && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
|
|
result2 = propertiesRelatedTo(source2, target2, reportStructuralErrors, void 0, intersectionState);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, target2, 0 /* Call */, reportStructuralErrors);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, target2, 1 /* Construct */, reportStructuralErrors);
|
|
if (result2) {
|
|
result2 &= indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportStructuralErrors, intersectionState);
|
|
}
|
|
}
|
|
}
|
|
if (varianceCheckFailed && result2) {
|
|
errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo;
|
|
} else if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 1048576 /* Union */) {
|
|
const objectOnlyTarget = extractTypesOfKind(target2, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
|
|
if (objectOnlyTarget.flags & 1048576 /* Union */) {
|
|
const result3 = typeRelatedToDiscriminatedType(source2, objectOnlyTarget);
|
|
if (result3) {
|
|
return result3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
function countMessageChainBreadth(info) {
|
|
if (!info)
|
|
return 0;
|
|
return reduceLeft(info, (value, chain) => value + 1 + countMessageChainBreadth(chain.next), 0);
|
|
}
|
|
function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState2) {
|
|
if (result2 = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors2, intersectionState2)) {
|
|
return result2;
|
|
}
|
|
if (some(variances, (v) => !!(v & 24 /* AllowsStructuralFallback */))) {
|
|
originalErrorInfo = void 0;
|
|
resetErrorInfo(saveErrorInfo);
|
|
return void 0;
|
|
}
|
|
const allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
|
|
varianceCheckFailed = !allowStructuralFallback;
|
|
if (variances !== emptyArray && !allowStructuralFallback) {
|
|
if (varianceCheckFailed && !(reportErrors2 && some(variances, (v) => (v & 7 /* VarianceMask */) === 0 /* Invariant */))) {
|
|
return 0 /* False */;
|
|
}
|
|
originalErrorInfo = errorInfo;
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
}
|
|
}
|
|
function mappedTypeRelatedTo(source2, target2, reportErrors2) {
|
|
const modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source2) === getMappedTypeModifiers(target2) : getCombinedMappedTypeOptionality(source2) <= getCombinedMappedTypeOptionality(target2));
|
|
if (modifiersRelated) {
|
|
let result2;
|
|
const targetConstraint = getConstraintTypeFromMappedType(target2);
|
|
const sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source2), getCombinedMappedTypeOptionality(source2) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper);
|
|
if (result2 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors2)) {
|
|
const mapper = createTypeMapper([getTypeParameterFromMappedType(source2)], [getTypeParameterFromMappedType(target2)]);
|
|
if (instantiateType(getNameTypeFromMappedType(source2), mapper) === instantiateType(getNameTypeFromMappedType(target2), mapper)) {
|
|
return result2 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source2), mapper), getTemplateTypeFromMappedType(target2), 3 /* Both */, reportErrors2);
|
|
}
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function typeRelatedToDiscriminatedType(source2, target2) {
|
|
var _a3;
|
|
const sourceProperties = getPropertiesOfType(source2);
|
|
const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target2);
|
|
if (!sourcePropertiesFiltered)
|
|
return 0 /* False */;
|
|
let numCombinations = 1;
|
|
for (const sourceProperty of sourcePropertiesFiltered) {
|
|
numCombinations *= countTypes(getNonMissingTypeOfSymbol(sourceProperty));
|
|
if (numCombinations > 25) {
|
|
(_a3 = tracing) == null ? void 0 : _a3.instant(tracing.Phase.CheckTypes, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source2.id, targetId: target2.id, numCombinations });
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length);
|
|
const excludedProperties = /* @__PURE__ */ new Set();
|
|
for (let i = 0; i < sourcePropertiesFiltered.length; i++) {
|
|
const sourceProperty = sourcePropertiesFiltered[i];
|
|
const sourcePropertyType = getNonMissingTypeOfSymbol(sourceProperty);
|
|
sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576 /* Union */ ? sourcePropertyType.types : [sourcePropertyType];
|
|
excludedProperties.add(sourceProperty.escapedName);
|
|
}
|
|
const discriminantCombinations = cartesianProduct(sourceDiscriminantTypes);
|
|
const matchingTypes = [];
|
|
for (const combination of discriminantCombinations) {
|
|
let hasMatch = false;
|
|
outer:
|
|
for (const type of target2.types) {
|
|
for (let i = 0; i < sourcePropertiesFiltered.length; i++) {
|
|
const sourceProperty = sourcePropertiesFiltered[i];
|
|
const targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
|
|
if (!targetProperty)
|
|
continue outer;
|
|
if (sourceProperty === targetProperty)
|
|
continue;
|
|
const related = propertyRelatedTo(source2, target2, sourceProperty, targetProperty, (_) => combination[i], false, 0 /* None */, strictNullChecks || relation === comparableRelation);
|
|
if (!related) {
|
|
continue outer;
|
|
}
|
|
}
|
|
pushIfUnique(matchingTypes, type, equateValues);
|
|
hasMatch = true;
|
|
}
|
|
if (!hasMatch) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (const type of matchingTypes) {
|
|
result2 &= propertiesRelatedTo(source2, type, false, excludedProperties, 0 /* None */);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, type, 0 /* Call */, false);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, type, 1 /* Construct */, false);
|
|
if (result2 && !(isTupleType(source2) && isTupleType(type))) {
|
|
result2 &= indexSignaturesRelatedTo(source2, type, false, false, 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
if (!result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function excludeProperties(properties, excludedProperties) {
|
|
if (!excludedProperties || properties.length === 0)
|
|
return properties;
|
|
let result2;
|
|
for (let i = 0; i < properties.length; i++) {
|
|
if (!excludedProperties.has(properties[i].escapedName)) {
|
|
if (result2) {
|
|
result2.push(properties[i]);
|
|
}
|
|
} else if (!result2) {
|
|
result2 = properties.slice(0, i);
|
|
}
|
|
}
|
|
return result2 || properties;
|
|
}
|
|
function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState) {
|
|
const targetIsOptional = strictNullChecks && !!(getCheckFlags(targetProp) & 48 /* Partial */);
|
|
const effectiveTarget = addOptionality(getNonMissingTypeOfSymbol(targetProp), false, targetIsOptional);
|
|
const effectiveSource = getTypeOfSourceProperty(sourceProp);
|
|
return isRelatedTo(effectiveSource, effectiveTarget, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
function propertyRelatedTo(source2, target2, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState, skipOptional) {
|
|
const sourcePropFlags = getDeclarationModifierFlagsFromSymbol(sourceProp);
|
|
const targetPropFlags = getDeclarationModifierFlagsFromSymbol(targetProp);
|
|
if (sourcePropFlags & 8 /* Private */ || targetPropFlags & 8 /* Private */) {
|
|
if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
|
|
if (reportErrors2) {
|
|
if (sourcePropFlags & 8 /* Private */ && targetPropFlags & 8 /* Private */) {
|
|
reportError(Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
|
|
} else {
|
|
reportError(
|
|
Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(sourcePropFlags & 8 /* Private */ ? source2 : target2),
|
|
typeToString(sourcePropFlags & 8 /* Private */ ? target2 : source2)
|
|
);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (targetPropFlags & 16 /* Protected */) {
|
|
if (!isValidOverrideOf(sourceProp, targetProp)) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2,
|
|
symbolToString(targetProp),
|
|
typeToString(getDeclaringClass(sourceProp) || source2),
|
|
typeToString(getDeclaringClass(targetProp) || target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (sourcePropFlags & 16 /* Protected */) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(source2),
|
|
typeToString(target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (relation === strictSubtypeRelation && isReadonlySymbol(sourceProp) && !isReadonlySymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
const related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!skipOptional && sourceProp.flags & 16777216 /* Optional */ && targetProp.flags & 106500 /* ClassMember */ && !(targetProp.flags & 16777216 /* Optional */)) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(source2),
|
|
typeToString(target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
return related;
|
|
}
|
|
function reportUnmatchedProperty(source2, target2, unmatchedProperty, requireOptionalProperties) {
|
|
let shouldSkipElaboration = false;
|
|
if (unmatchedProperty.valueDeclaration && isNamedDeclaration(unmatchedProperty.valueDeclaration) && isPrivateIdentifier(unmatchedProperty.valueDeclaration.name) && source2.symbol && source2.symbol.flags & 32 /* Class */) {
|
|
const privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText;
|
|
const symbolTableKey = getSymbolNameForPrivateIdentifier(source2.symbol, privateIdentifierDescription);
|
|
if (symbolTableKey && getPropertyOfType(source2, symbolTableKey)) {
|
|
const sourceName = factory.getDeclarationName(source2.symbol.valueDeclaration);
|
|
const targetName = factory.getDeclarationName(target2.symbol.valueDeclaration);
|
|
reportError(
|
|
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;
|
|
}
|
|
}
|
|
const props = arrayFrom(getUnmatchedProperties(source2, target2, requireOptionalProperties, false));
|
|
if (!headMessage || headMessage.code !== Diagnostics.Class_0_incorrectly_implements_interface_1.code && headMessage.code !== Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code) {
|
|
shouldSkipElaboration = true;
|
|
}
|
|
if (props.length === 1) {
|
|
const propName = symbolToString(unmatchedProperty, void 0, 0 /* None */, 4 /* AllowAnyNodeKind */ | 16 /* WriteComputedProps */);
|
|
reportError(Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName, ...getTypeNamesForErrorDisplay(source2, target2));
|
|
if (length(unmatchedProperty.declarations)) {
|
|
associateRelatedInfo(createDiagnosticForNode(unmatchedProperty.declarations[0], Diagnostics._0_is_declared_here, propName));
|
|
}
|
|
if (shouldSkipElaboration && errorInfo) {
|
|
overrideNextErrorInfo++;
|
|
}
|
|
} else if (tryElaborateArrayLikeErrors(source2, target2, false)) {
|
|
if (props.length > 5) {
|
|
reportError(Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source2), typeToString(target2), map(props.slice(0, 4), (p) => symbolToString(p)).join(", "), props.length - 4);
|
|
} else {
|
|
reportError(Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source2), typeToString(target2), map(props, (p) => symbolToString(p)).join(", "));
|
|
}
|
|
if (shouldSkipElaboration && errorInfo) {
|
|
overrideNextErrorInfo++;
|
|
}
|
|
}
|
|
}
|
|
function propertiesRelatedTo(source2, target2, reportErrors2, excludedProperties, intersectionState) {
|
|
if (relation === identityRelation) {
|
|
return propertiesIdenticalTo(source2, target2, excludedProperties);
|
|
}
|
|
let result2 = -1 /* True */;
|
|
if (isTupleType(target2)) {
|
|
if (isArrayOrTupleType(source2)) {
|
|
if (!target2.target.readonly && (isReadonlyArrayType(source2) || isTupleType(source2) && source2.target.readonly)) {
|
|
return 0 /* False */;
|
|
}
|
|
const sourceArity = getTypeReferenceArity(source2);
|
|
const targetArity = getTypeReferenceArity(target2);
|
|
const sourceRestFlag = isTupleType(source2) ? source2.target.combinedFlags & 4 /* Rest */ : 4 /* Rest */;
|
|
const targetRestFlag = target2.target.combinedFlags & 4 /* Rest */;
|
|
const sourceMinLength = isTupleType(source2) ? source2.target.minLength : 0;
|
|
const targetMinLength = target2.target.minLength;
|
|
if (!sourceRestFlag && sourceArity < targetMinLength) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_has_0_element_s_but_target_requires_1, sourceArity, targetMinLength);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!targetRestFlag && targetArity < sourceMinLength) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_has_0_element_s_but_target_allows_only_1, sourceMinLength, targetArity);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!targetRestFlag && (sourceRestFlag || targetArity < sourceArity)) {
|
|
if (reportErrors2) {
|
|
if (sourceMinLength < targetMinLength) {
|
|
reportError(Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer, targetMinLength);
|
|
} else {
|
|
reportError(Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more, targetArity);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const sourceTypeArguments = getTypeArguments(source2);
|
|
const targetTypeArguments = getTypeArguments(target2);
|
|
const targetStartCount = getStartElementCount(target2.target, 11 /* NonRest */);
|
|
const targetEndCount = getEndElementCount(target2.target, 11 /* NonRest */);
|
|
const targetHasRestElement = target2.target.hasRestElement;
|
|
let canExcludeDiscriminants = !!excludedProperties;
|
|
for (let sourcePosition = 0; sourcePosition < sourceArity; sourcePosition++) {
|
|
const sourceFlags = isTupleType(source2) ? source2.target.elementFlags[sourcePosition] : 4 /* Rest */;
|
|
const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
|
|
const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount) : sourcePosition;
|
|
const targetFlags = target2.target.elementFlags[targetPosition];
|
|
if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourcePosition, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (targetFlags & 1 /* Required */ && !(sourceFlags & 1 /* Required */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (canExcludeDiscriminants) {
|
|
if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) {
|
|
canExcludeDiscriminants = false;
|
|
}
|
|
if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + sourcePosition))) {
|
|
continue;
|
|
}
|
|
}
|
|
const sourceType = removeMissingType(sourceTypeArguments[sourcePosition], !!(sourceFlags & targetFlags & 2 /* Optional */));
|
|
const targetType = targetTypeArguments[targetPosition];
|
|
const targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : removeMissingType(targetType, !!(targetFlags & 2 /* Optional */));
|
|
const related = isRelatedTo(sourceType, targetCheckType, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
if (reportErrors2 && (targetArity > 1 || sourceArity > 1)) {
|
|
if (targetHasRestElement && sourcePosition >= targetStartCount && sourcePositionFromEnd >= targetEndCount && targetStartCount !== sourceArity - targetEndCount - 1) {
|
|
reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, targetStartCount, sourceArity - targetEndCount - 1, targetPosition);
|
|
} else {
|
|
reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourcePosition, targetPosition);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
if (target2.target.combinedFlags & 12 /* Variable */) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source2) && !isEmptyArrayLiteralType(source2) && !isTupleType(source2);
|
|
const unmatchedProperty = getUnmatchedProperty(source2, target2, requireOptionalProperties, false);
|
|
if (unmatchedProperty) {
|
|
if (reportErrors2 && shouldReportUnmatchedPropertyError(source2, target2)) {
|
|
reportUnmatchedProperty(source2, target2, unmatchedProperty, requireOptionalProperties);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (isObjectLiteralType(target2)) {
|
|
for (const sourceProp of excludeProperties(getPropertiesOfType(source2), excludedProperties)) {
|
|
if (!getPropertyOfObjectType(target2, sourceProp.escapedName)) {
|
|
const sourceType = getTypeOfSymbol(sourceProp);
|
|
if (!(sourceType.flags & 32768 /* Undefined */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target2));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const properties = getPropertiesOfType(target2);
|
|
const numericNamesOnly = isTupleType(source2) && isTupleType(target2);
|
|
for (const targetProp of excludeProperties(properties, excludedProperties)) {
|
|
const name = targetProp.escapedName;
|
|
if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
|
|
const sourceProp = getPropertyOfType(source2, name);
|
|
if (sourceProp && sourceProp !== targetProp) {
|
|
const related = propertyRelatedTo(source2, target2, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors2, intersectionState, relation === comparableRelation);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function propertiesIdenticalTo(source2, target2, excludedProperties) {
|
|
if (!(source2.flags & 524288 /* Object */ && target2.flags & 524288 /* Object */)) {
|
|
return 0 /* False */;
|
|
}
|
|
const sourceProperties = excludeProperties(getPropertiesOfObjectType(source2), excludedProperties);
|
|
const targetProperties = excludeProperties(getPropertiesOfObjectType(target2), excludedProperties);
|
|
if (sourceProperties.length !== targetProperties.length) {
|
|
return 0 /* False */;
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (const sourceProp of sourceProperties) {
|
|
const targetProp = getPropertyOfObjectType(target2, sourceProp.escapedName);
|
|
if (!targetProp) {
|
|
return 0 /* False */;
|
|
}
|
|
const related = compareProperties(sourceProp, targetProp, isRelatedTo);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function signaturesRelatedTo(source2, target2, kind, reportErrors2) {
|
|
var _a3, _b;
|
|
if (relation === identityRelation) {
|
|
return signaturesIdenticalTo(source2, target2, kind);
|
|
}
|
|
if (target2 === anyFunctionType || source2 === anyFunctionType) {
|
|
return -1 /* True */;
|
|
}
|
|
const sourceIsJSConstructor = source2.symbol && isJSConstructor(source2.symbol.valueDeclaration);
|
|
const targetIsJSConstructor = target2.symbol && isJSConstructor(target2.symbol.valueDeclaration);
|
|
const sourceSignatures = getSignaturesOfType(source2, sourceIsJSConstructor && kind === 1 /* Construct */ ? 0 /* Call */ : kind);
|
|
const targetSignatures = getSignaturesOfType(target2, targetIsJSConstructor && kind === 1 /* Construct */ ? 0 /* Call */ : kind);
|
|
if (kind === 1 /* Construct */ && sourceSignatures.length && targetSignatures.length) {
|
|
const sourceIsAbstract = !!(sourceSignatures[0].flags & 4 /* Abstract */);
|
|
const targetIsAbstract = !!(targetSignatures[0].flags & 4 /* Abstract */);
|
|
if (sourceIsAbstract && !targetIsAbstract) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors2)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
let result2 = -1 /* True */;
|
|
const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
|
|
const sourceObjectFlags = getObjectFlags(source2);
|
|
const targetObjectFlags = getObjectFlags(target2);
|
|
if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
|
|
for (let i = 0; i < targetSignatures.length; i++) {
|
|
const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors2, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
} else if (sourceSignatures.length === 1 && targetSignatures.length === 1) {
|
|
const eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
|
|
const sourceSignature = first(sourceSignatures);
|
|
const targetSignature = first(targetSignatures);
|
|
result2 = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors2, incompatibleReporter(sourceSignature, targetSignature));
|
|
if (!result2 && reportErrors2 && kind === 1 /* Construct */ && sourceObjectFlags & targetObjectFlags && (((_a3 = targetSignature.declaration) == null ? void 0 : _a3.kind) === 173 /* Constructor */ || ((_b = sourceSignature.declaration) == null ? void 0 : _b.kind) === 173 /* Constructor */)) {
|
|
const constructSignatureToString = (signature) => signatureToString(signature, void 0, 262144 /* WriteArrowStyleSignature */, kind);
|
|
reportError(Diagnostics.Type_0_is_not_assignable_to_type_1, constructSignatureToString(sourceSignature), constructSignatureToString(targetSignature));
|
|
reportError(Diagnostics.Types_of_construct_signatures_are_incompatible);
|
|
return result2;
|
|
}
|
|
} else {
|
|
outer:
|
|
for (const t of targetSignatures) {
|
|
const saveErrorInfo = captureErrorCalculationState();
|
|
let shouldElaborateErrors = reportErrors2;
|
|
for (const s of sourceSignatures) {
|
|
const related = signatureRelatedTo(s, t, true, shouldElaborateErrors, incompatibleReporter(s, t));
|
|
if (related) {
|
|
result2 &= related;
|
|
resetErrorInfo(saveErrorInfo);
|
|
continue outer;
|
|
}
|
|
shouldElaborateErrors = false;
|
|
}
|
|
if (shouldElaborateErrors) {
|
|
reportError(
|
|
Diagnostics.Type_0_provides_no_match_for_the_signature_1,
|
|
typeToString(source2),
|
|
signatureToString(t, void 0, void 0, kind)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function shouldReportUnmatchedPropertyError(source2, target2) {
|
|
const typeCallSignatures = getSignaturesOfStructuredType(source2, 0 /* Call */);
|
|
const typeConstructSignatures = getSignaturesOfStructuredType(source2, 1 /* Construct */);
|
|
const typeProperties = getPropertiesOfObjectType(source2);
|
|
if ((typeCallSignatures.length || typeConstructSignatures.length) && !typeProperties.length) {
|
|
if (getSignaturesOfType(target2, 0 /* Call */).length && typeCallSignatures.length || getSignaturesOfType(target2, 1 /* Construct */).length && typeConstructSignatures.length) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function reportIncompatibleCallSignatureReturn(siga, sigb) {
|
|
if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
|
|
}
|
|
function reportIncompatibleConstructSignatureReturn(siga, sigb) {
|
|
if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
|
|
}
|
|
function signatureRelatedTo(source2, target2, erase, reportErrors2, incompatibleReporter) {
|
|
return compareSignaturesRelated(
|
|
erase ? getErasedSignature(source2) : source2,
|
|
erase ? getErasedSignature(target2) : target2,
|
|
relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0,
|
|
reportErrors2,
|
|
reportError,
|
|
incompatibleReporter,
|
|
isRelatedToWorker,
|
|
reportUnreliableMapper
|
|
);
|
|
}
|
|
function signaturesIdenticalTo(source2, target2, kind) {
|
|
const sourceSignatures = getSignaturesOfType(source2, kind);
|
|
const targetSignatures = getSignaturesOfType(target2, kind);
|
|
if (sourceSignatures.length !== targetSignatures.length) {
|
|
return 0 /* False */;
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (let i = 0; i < sourceSignatures.length; i++) {
|
|
const related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], false, false, false, isRelatedTo);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function membersRelatedToIndexInfo(source2, targetInfo, reportErrors2) {
|
|
let result2 = -1 /* True */;
|
|
const keyType = targetInfo.keyType;
|
|
const props = source2.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(source2) : getPropertiesOfObjectType(source2);
|
|
for (const prop of props) {
|
|
if (isIgnoredJsxProperty(source2, prop)) {
|
|
continue;
|
|
}
|
|
if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), keyType)) {
|
|
const propType = getNonMissingTypeOfSymbol(prop);
|
|
const type = exactOptionalPropertyTypes || propType.flags & 32768 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */) ? propType : getTypeWithFacts(propType, 524288 /* NEUndefined */);
|
|
const related = isRelatedTo(type, targetInfo.type, 3 /* Both */, reportErrors2);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
for (const info of getIndexInfosOfType(source2)) {
|
|
if (isApplicableIndexType(info.keyType, keyType)) {
|
|
const related = indexInfoRelatedTo(info, targetInfo, reportErrors2);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2) {
|
|
const related = isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */, reportErrors2);
|
|
if (!related && reportErrors2) {
|
|
if (sourceInfo.keyType === targetInfo.keyType) {
|
|
reportError(Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType));
|
|
} else {
|
|
reportError(Diagnostics._0_and_1_index_signatures_are_incompatible, typeToString(sourceInfo.keyType), typeToString(targetInfo.keyType));
|
|
}
|
|
}
|
|
return related;
|
|
}
|
|
function indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportErrors2, intersectionState) {
|
|
if (relation === identityRelation) {
|
|
return indexSignaturesIdenticalTo(source2, target2);
|
|
}
|
|
const indexInfos = getIndexInfosOfType(target2);
|
|
const targetHasStringIndex = some(indexInfos, (info) => info.keyType === stringType);
|
|
let result2 = -1 /* True */;
|
|
for (const targetInfo of indexInfos) {
|
|
const related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ : isGenericMappedType(source2) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source2), targetInfo.type, 3 /* Both */, reportErrors2) : typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState) {
|
|
const sourceInfo = getApplicableIndexInfo(source2, targetInfo.keyType);
|
|
if (sourceInfo) {
|
|
return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2);
|
|
}
|
|
if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
|
|
return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2);
|
|
}
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Index_signature_for_type_0_is_missing_in_type_1, typeToString(targetInfo.keyType), typeToString(source2));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function indexSignaturesIdenticalTo(source2, target2) {
|
|
const sourceInfos = getIndexInfosOfType(source2);
|
|
const targetInfos = getIndexInfosOfType(target2);
|
|
if (sourceInfos.length !== targetInfos.length) {
|
|
return 0 /* False */;
|
|
}
|
|
for (const targetInfo of targetInfos) {
|
|
const sourceInfo = getIndexInfoOfType(source2, targetInfo.keyType);
|
|
if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
return -1 /* True */;
|
|
}
|
|
function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors2) {
|
|
if (!sourceSignature.declaration || !targetSignature.declaration) {
|
|
return true;
|
|
}
|
|
const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
if (targetAccessibility === 8 /* Private */) {
|
|
return true;
|
|
}
|
|
if (targetAccessibility === 16 /* Protected */ && sourceAccessibility !== 8 /* Private */) {
|
|
return true;
|
|
}
|
|
if (targetAccessibility !== 16 /* Protected */ && !sourceAccessibility) {
|
|
return true;
|
|
}
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility));
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function typeCouldHaveTopLevelSingletonTypes(type) {
|
|
if (type.flags & 16 /* Boolean */) {
|
|
return false;
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
return !!forEach(type.types, typeCouldHaveTopLevelSingletonTypes);
|
|
}
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
const constraint = getConstraintOfType(type);
|
|
if (constraint && constraint !== type) {
|
|
return typeCouldHaveTopLevelSingletonTypes(constraint);
|
|
}
|
|
}
|
|
return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */) || !!(type.flags & 268435456 /* StringMapping */);
|
|
}
|
|
function getExactOptionalUnassignableProperties(source, target) {
|
|
if (isTupleType(source) && isTupleType(target))
|
|
return emptyArray;
|
|
return getPropertiesOfType(target).filter((targetProp) => isExactOptionalPropertyMismatch(getTypeOfPropertyOfType(source, targetProp.escapedName), getTypeOfSymbol(targetProp)));
|
|
}
|
|
function isExactOptionalPropertyMismatch(source, target) {
|
|
return !!source && !!target && maybeTypeOfKind(source, 32768 /* Undefined */) && !!containsMissingType(target);
|
|
}
|
|
function getExactOptionalProperties(type) {
|
|
return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
|
|
}
|
|
function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
|
|
return findMatchingDiscriminantType(source, target, isRelatedTo, true) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
|
|
}
|
|
function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
|
|
const discriminable = target.types.map((_) => void 0);
|
|
for (const [getDiscriminatingType, propertyName] of discriminators) {
|
|
const targetProp = getUnionOrIntersectionProperty(target, propertyName);
|
|
if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
|
|
continue;
|
|
}
|
|
let i = 0;
|
|
for (const type of target.types) {
|
|
const targetType = getTypeOfPropertyOfType(type, propertyName);
|
|
if (targetType && related(getDiscriminatingType(), targetType)) {
|
|
discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
|
|
} else {
|
|
discriminable[i] = false;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
const match = discriminable.indexOf(true);
|
|
if (match === -1) {
|
|
return defaultValue;
|
|
}
|
|
let nextMatch = discriminable.indexOf(true, match + 1);
|
|
while (nextMatch !== -1) {
|
|
if (!isTypeIdenticalTo(target.types[match], target.types[nextMatch])) {
|
|
return defaultValue;
|
|
}
|
|
nextMatch = discriminable.indexOf(true, nextMatch + 1);
|
|
}
|
|
return target.types[match];
|
|
}
|
|
function isWeakType(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return every(type.types, isWeakType);
|
|
}
|
|
return false;
|
|
}
|
|
function hasCommonProperties(source, target, isComparingJsxAttributes) {
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getVariances(type) {
|
|
return type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8 /* Tuple */ ? arrayVariances : getVariancesWorker(type.symbol, type.typeParameters);
|
|
}
|
|
function getAliasVariances(symbol) {
|
|
return getVariancesWorker(symbol, getSymbolLinks(symbol).typeParameters);
|
|
}
|
|
function getVariancesWorker(symbol, typeParameters = emptyArray) {
|
|
var _a2, _b;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.variances) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.CheckTypes, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
|
|
links.variances = emptyArray;
|
|
const variances = [];
|
|
for (const tp of typeParameters) {
|
|
const modifiers = getVarianceModifiers(tp);
|
|
let variance = modifiers & 65536 /* Out */ ? modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 32768 /* In */ ? 2 /* Contravariant */ : void 0;
|
|
if (variance === void 0) {
|
|
let unmeasurable = false;
|
|
let unreliable = false;
|
|
const oldHandler = outofbandVarianceMarkerHandler;
|
|
outofbandVarianceMarkerHandler = (onlyUnreliable) => onlyUnreliable ? unreliable = true : unmeasurable = true;
|
|
const typeWithSuper = createMarkerType(symbol, tp, markerSuperType);
|
|
const typeWithSub = createMarkerType(symbol, tp, markerSubType);
|
|
variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 /* Covariant */ : 0) | (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 /* Contravariant */ : 0);
|
|
if (variance === 3 /* Bivariant */ && isTypeAssignableTo(createMarkerType(symbol, tp, markerOtherType), typeWithSuper)) {
|
|
variance = 4 /* Independent */;
|
|
}
|
|
outofbandVarianceMarkerHandler = oldHandler;
|
|
if (unmeasurable || unreliable) {
|
|
if (unmeasurable) {
|
|
variance |= 8 /* Unmeasurable */;
|
|
}
|
|
if (unreliable) {
|
|
variance |= 16 /* Unreliable */;
|
|
}
|
|
}
|
|
}
|
|
variances.push(variance);
|
|
}
|
|
links.variances = variances;
|
|
(_b = tracing) == null ? void 0 : _b.pop({ variances: variances.map(Debug.formatVariance) });
|
|
}
|
|
return links.variances;
|
|
}
|
|
function createMarkerType(symbol, source, target) {
|
|
const mapper = makeUnaryTypeMapper(source, target);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (isErrorType(type)) {
|
|
return type;
|
|
}
|
|
const result = symbol.flags & 524288 /* 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 _a2, _b;
|
|
return (some((_a2 = tp.symbol) == null ? void 0 : _a2.declarations, (d) => hasSyntacticModifier(d, 32768 /* In */)) ? 32768 /* In */ : 0) | (some((_b = tp.symbol) == null ? void 0 : _b.declarations, (d) => hasSyntacticModifier(d, 65536 /* Out */)) ? 65536 /* Out */ : 0);
|
|
}
|
|
function hasCovariantVoidArgument(typeArguments, variances) {
|
|
for (let i = 0; i < variances.length; i++) {
|
|
if ((variances[i] & 7 /* VarianceMask */) === 1 /* Covariant */ && typeArguments[i].flags & 16384 /* Void */) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isUnconstrainedTypeParameter(type) {
|
|
return type.flags & 262144 /* TypeParameter */ && !getConstraintOfTypeParameter(type);
|
|
}
|
|
function isNonDeferredTypeReference(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */) && !type.node;
|
|
}
|
|
function isTypeReferenceWithGenericArguments(type) {
|
|
return isNonDeferredTypeReference(type) && some(getTypeArguments(type), (t) => !!(t.flags & 262144 /* TypeParameter */) || isTypeReferenceWithGenericArguments(t));
|
|
}
|
|
function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) {
|
|
const typeParameters = [];
|
|
let constraintMarker = "";
|
|
const sourceId = getTypeReferenceId(source, 0);
|
|
const targetId = getTypeReferenceId(target, 0);
|
|
return `${constraintMarker}${sourceId},${targetId}${postFix}`;
|
|
function getTypeReferenceId(type, depth = 0) {
|
|
let result = "" + type.target.id;
|
|
for (const t of getTypeArguments(type)) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
|
|
let index = typeParameters.indexOf(t);
|
|
if (index < 0) {
|
|
index = typeParameters.length;
|
|
typeParameters.push(t);
|
|
}
|
|
result += "=" + index;
|
|
continue;
|
|
}
|
|
constraintMarker = "*";
|
|
} else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
|
|
result += "<" + getTypeReferenceId(t, depth + 1) + ">";
|
|
continue;
|
|
}
|
|
result += "-" + t.id;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) {
|
|
if (relation === identityRelation && source.id > target.id) {
|
|
const temp = source;
|
|
source = target;
|
|
target = temp;
|
|
}
|
|
const postFix = intersectionState ? ":" + intersectionState : "";
|
|
return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ? getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) : `${source.id},${target.id}${postFix}`;
|
|
}
|
|
function forEachProperty(prop, callback) {
|
|
if (getCheckFlags(prop) & 6 /* Synthetic */) {
|
|
for (const t of prop.containingType.types) {
|
|
const p = getPropertyOfType(t, prop.escapedName);
|
|
const result = p && forEachProperty(p, callback);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
return callback(prop);
|
|
}
|
|
function getDeclaringClass(prop) {
|
|
return prop.parent && prop.parent.flags & 32 /* Class */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : void 0;
|
|
}
|
|
function getTypeOfPropertyInBaseClass(property) {
|
|
const classType = getDeclaringClass(property);
|
|
const baseClassType = classType && getBaseTypes(classType)[0];
|
|
return baseClassType && getTypeOfPropertyOfType(baseClassType, property.escapedName);
|
|
}
|
|
function isPropertyInClassDerivedFrom(prop, baseClass) {
|
|
return forEachProperty(prop, (sp) => {
|
|
const sourceClass = getDeclaringClass(sp);
|
|
return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
|
|
});
|
|
}
|
|
function isValidOverrideOf(sourceProp, targetProp) {
|
|
return !forEachProperty(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 16 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
|
|
}
|
|
function isClassDerivedFromDeclaringClasses(checkClass, prop, writing) {
|
|
return forEachProperty(prop, (p) => getDeclarationModifierFlagsFromSymbol(p, writing) & 16 /* Protected */ ? !hasBaseType(checkClass, getDeclaringClass(p)) : false) ? void 0 : checkClass;
|
|
}
|
|
function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
|
|
if (depth >= maxDepth) {
|
|
const identity2 = getRecursionIdentity(type);
|
|
let count = 0;
|
|
let lastTypeId = 0;
|
|
for (let i = 0; i < depth; i++) {
|
|
const t = stack[i];
|
|
if (getRecursionIdentity(t) === identity2) {
|
|
if (t.id >= lastTypeId) {
|
|
count++;
|
|
if (count >= maxDepth) {
|
|
return true;
|
|
}
|
|
}
|
|
lastTypeId = t.id;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getRecursionIdentity(type) {
|
|
if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
|
|
if (getObjectFlags(type) && 4 /* Reference */ && type.node) {
|
|
return type.node;
|
|
}
|
|
if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
|
|
return type.symbol;
|
|
}
|
|
if (isTupleType(type)) {
|
|
return type.target;
|
|
}
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
return type.symbol;
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
do {
|
|
type = type.objectType;
|
|
} while (type.flags & 8388608 /* IndexedAccess */);
|
|
return type;
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
return type.root;
|
|
}
|
|
return type;
|
|
}
|
|
function isPropertyIdenticalTo(sourceProp, targetProp) {
|
|
return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
|
|
}
|
|
function compareProperties(sourceProp, targetProp, compareTypes) {
|
|
if (sourceProp === targetProp) {
|
|
return -1 /* True */;
|
|
}
|
|
const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 24 /* NonPublicAccessibilityModifier */;
|
|
const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 24 /* NonPublicAccessibilityModifier */;
|
|
if (sourcePropAccessibility !== targetPropAccessibility) {
|
|
return 0 /* False */;
|
|
}
|
|
if (sourcePropAccessibility) {
|
|
if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
} else {
|
|
if ((sourceProp.flags & 16777216 /* Optional */) !== (targetProp.flags & 16777216 /* Optional */)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
|
|
}
|
|
function isMatchingSignature(source, target, partialMatch) {
|
|
const sourceParameterCount = getParameterCount(source);
|
|
const targetParameterCount = getParameterCount(target);
|
|
const sourceMinArgumentCount = getMinArgumentCount(source);
|
|
const targetMinArgumentCount = getMinArgumentCount(target);
|
|
const sourceHasRestParameter = hasEffectiveRestParameter(source);
|
|
const targetHasRestParameter = hasEffectiveRestParameter(target);
|
|
if (sourceParameterCount === targetParameterCount && sourceMinArgumentCount === targetMinArgumentCount && sourceHasRestParameter === targetHasRestParameter) {
|
|
return true;
|
|
}
|
|
if (partialMatch && sourceMinArgumentCount <= targetMinArgumentCount) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) {
|
|
if (source === target) {
|
|
return -1 /* True */;
|
|
}
|
|
if (!isMatchingSignature(source, target, partialMatch)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (length(source.typeParameters) !== length(target.typeParameters)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (target.typeParameters) {
|
|
const mapper = createTypeMapper(source.typeParameters, target.typeParameters);
|
|
for (let i = 0; i < target.typeParameters.length; i++) {
|
|
const s = source.typeParameters[i];
|
|
const 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 /* False */;
|
|
}
|
|
}
|
|
source = instantiateSignature(source, mapper, true);
|
|
}
|
|
let result = -1 /* True */;
|
|
if (!ignoreThisTypes) {
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
const related = compareTypes(sourceThisType, targetThisType);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
}
|
|
const targetLen = getParameterCount(target);
|
|
for (let i = 0; i < targetLen; i++) {
|
|
const s = getTypeAtPosition(source, i);
|
|
const t = getTypeAtPosition(target, i);
|
|
const related = compareTypes(t, s);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
if (!ignoreReturnTypes) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
const 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 /* False */ : source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type) : 0 /* False */;
|
|
}
|
|
function literalTypesWithSameBaseType(types) {
|
|
let commonBaseType;
|
|
for (const t of types) {
|
|
if (!(t.flags & 131072 /* Never */)) {
|
|
const baseType = getBaseTypeOfLiteralType(t);
|
|
commonBaseType != null ? commonBaseType : commonBaseType = baseType;
|
|
if (baseType === t || baseType !== commonBaseType) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getCombinedTypeFlags(types) {
|
|
return reduceLeft(types, (flags, t) => flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags), 0);
|
|
}
|
|
function getCommonSupertype(types) {
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
const primaryTypes = strictNullChecks ? sameMap(types, (t) => filterType(t, (u) => !(u.flags & 98304 /* Nullable */))) : types;
|
|
const superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ? getUnionType(primaryTypes) : reduceLeft(primaryTypes, (s, t) => isTypeSubtypeOf(s, t) ? t : s);
|
|
return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
|
|
}
|
|
function getCommonSubtype(types) {
|
|
return reduceLeft(types, (s, t) => isTypeSubtypeOf(t, s) ? t : s);
|
|
}
|
|
function isArrayType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */) && (type.target === globalArrayType || type.target === globalReadonlyArrayType);
|
|
}
|
|
function isReadonlyArrayType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* 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] : void 0;
|
|
}
|
|
function isArrayLikeType(type) {
|
|
return isArrayType(type) || !(type.flags & 98304 /* Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType);
|
|
}
|
|
function getSingleBaseForNonAugmentingSubtype(type) {
|
|
if (!(getObjectFlags(type) & 4 /* Reference */) || !(getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
|
|
return void 0;
|
|
}
|
|
if (getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
|
|
return getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : void 0;
|
|
}
|
|
type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
|
|
const target = type.target;
|
|
if (getObjectFlags(target) & 1 /* Class */) {
|
|
const baseTypeNode = getBaseTypeNodeOfClass(target);
|
|
if (baseTypeNode && baseTypeNode.expression.kind !== 79 /* Identifier */ && baseTypeNode.expression.kind !== 208 /* PropertyAccessExpression */) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const bases = getBaseTypes(target);
|
|
if (bases.length !== 1) {
|
|
return void 0;
|
|
}
|
|
if (getMembersOfSymbol(type.symbol).size) {
|
|
return void 0;
|
|
}
|
|
let instantiatedBase = !length(target.typeParameters) ? bases[0] : instantiateType(bases[0], createTypeMapper(target.typeParameters, getTypeArguments(type).slice(0, target.typeParameters.length)));
|
|
if (length(getTypeArguments(type)) > length(target.typeParameters)) {
|
|
instantiatedBase = getTypeWithThisArgument(instantiatedBase, last(getTypeArguments(type)));
|
|
}
|
|
type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
|
|
return type.cachedEquivalentBaseType = instantiatedBase;
|
|
}
|
|
function isEmptyLiteralType(type) {
|
|
return strictNullChecks ? type === implicitNeverType : type === undefinedWideningType;
|
|
}
|
|
function isEmptyArrayLiteralType(type) {
|
|
const 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) {
|
|
const propType = getTypeOfPropertyOfType(type, "" + index);
|
|
if (propType) {
|
|
return propType;
|
|
}
|
|
if (everyType(type, isTupleType)) {
|
|
return mapType(type, (t) => getRestTypeOfTupleType(t) || undefinedType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isNeitherUnitTypeNorNever(type) {
|
|
return !(type.flags & (109440 /* Unit */ | 131072 /* Never */));
|
|
}
|
|
function isUnitType(type) {
|
|
return !!(type.flags & 109440 /* Unit */);
|
|
}
|
|
function isUnitLikeType(type) {
|
|
return isUnitType(getBaseConstraintOrType(type));
|
|
}
|
|
function extractUnitType(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? find(type.types, isUnitType) || type : type;
|
|
}
|
|
function isLiteralType(type) {
|
|
return type.flags & 16 /* Boolean */ ? true : type.flags & 1048576 /* Union */ ? type.flags & 1024 /* EnumLiteral */ ? true : every(type.types, isUnitType) : isUnitType(type);
|
|
}
|
|
function getBaseTypeOfLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ ? getBaseTypeOfEnumLiteralType(type) : type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
|
|
}
|
|
function getBaseTypeOfLiteralTypeUnion(type) {
|
|
var _a2;
|
|
const key = `B${getTypeId(type)}`;
|
|
return (_a2 = getCachedType(key)) != null ? _a2 : setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
|
|
}
|
|
function getWidenedLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
|
|
}
|
|
function getWidenedUniqueESSymbolType(type) {
|
|
return type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : type.flags & 1048576 /* 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)) {
|
|
const contextualType = !contextualSignatureReturnType ? void 0 : isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) : contextualSignatureReturnType;
|
|
type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
|
|
}
|
|
return type;
|
|
}
|
|
function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) {
|
|
if (type && isUnitType(type)) {
|
|
const contextualType = !contextualSignatureReturnType ? void 0 : getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator);
|
|
type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
|
|
}
|
|
return type;
|
|
}
|
|
function isTupleType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */ && type.target.objectFlags & 8 /* Tuple */);
|
|
}
|
|
function isGenericTupleType(type) {
|
|
return isTupleType(type) && !!(type.target.combinedFlags & 8 /* Variadic */);
|
|
}
|
|
function isSingleElementGenericTupleType(type) {
|
|
return isGenericTupleType(type) && type.target.elementFlags.length === 1;
|
|
}
|
|
function getRestTypeOfTupleType(type) {
|
|
return getElementTypeOfSliceOfTupleType(type, type.target.fixedLength);
|
|
}
|
|
function getRestArrayTypeOfTupleType(type) {
|
|
const restType = getRestTypeOfTupleType(type);
|
|
return restType && createArrayType(restType);
|
|
}
|
|
function getElementTypeOfSliceOfTupleType(type, index, endSkipCount = 0, writing = false) {
|
|
const length2 = getTypeReferenceArity(type) - endSkipCount;
|
|
if (index < length2) {
|
|
const typeArguments = getTypeArguments(type);
|
|
const elementTypes = [];
|
|
for (let i = index; i < length2; i++) {
|
|
const t = typeArguments[i];
|
|
elementTypes.push(type.target.elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t);
|
|
}
|
|
return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isTupleTypeStructureMatching(t1, t2) {
|
|
return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
|
|
}
|
|
function isZeroBigInt({ value }) {
|
|
return value.base10Value === "0";
|
|
}
|
|
function removeDefinitelyFalsyTypes(type) {
|
|
return filterType(type, (t) => !!(getTypeFacts(t) & 4194304 /* Truthy */));
|
|
}
|
|
function extractDefinitelyFalsyTypes(type) {
|
|
return mapType(type, getDefinitelyFalsyPartOfType);
|
|
}
|
|
function getDefinitelyFalsyPartOfType(type) {
|
|
return type.flags & 4 /* String */ ? emptyStringType : type.flags & 8 /* Number */ ? zeroType : type.flags & 64 /* BigInt */ ? zeroBigIntType : type === regularFalseType || type === falseType || type.flags & (16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */ | 3 /* AnyOrUnknown */) || type.flags & 128 /* StringLiteral */ && type.value === "" || type.flags & 256 /* NumberLiteral */ && type.value === 0 || type.flags & 2048 /* BigIntLiteral */ && isZeroBigInt(type) ? type : neverType;
|
|
}
|
|
function getNullableType(type, flags) {
|
|
const missing = flags & ~type.flags & (32768 /* Undefined */ | 65536 /* Null */);
|
|
return missing === 0 ? type : missing === 32768 /* Undefined */ ? getUnionType([type, undefinedType]) : missing === 65536 /* Null */ ? getUnionType([type, nullType]) : getUnionType([type, undefinedType, nullType]);
|
|
}
|
|
function getOptionalType(type, isProperty = false) {
|
|
Debug.assert(strictNullChecks);
|
|
const missingOrUndefined = isProperty ? missingType : undefinedType;
|
|
return type.flags & 32768 /* Undefined */ || type.flags & 1048576 /* Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
|
|
}
|
|
function getGlobalNonNullableTypeInstantiation(type) {
|
|
if (!deferredGlobalNonNullableTypeAlias) {
|
|
deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* TypeAlias */, void 0) || unknownSymbol;
|
|
}
|
|
return deferredGlobalNonNullableTypeAlias !== unknownSymbol ? getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) : getIntersectionType([type, emptyObjectType]);
|
|
}
|
|
function getNonNullableType(type) {
|
|
return strictNullChecks ? getAdjustedTypeWithFacts(type, 2097152 /* 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 ? isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type;
|
|
}
|
|
function getOptionalExpressionType(exprType, expression) {
|
|
return isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) : 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 /* Union */ && containsType(type.types, missingType));
|
|
}
|
|
function removeMissingOrUndefinedType(type) {
|
|
return exactOptionalPropertyTypes ? removeType(type, missingType) : getTypeWithFacts(type, 524288 /* NEUndefined */);
|
|
}
|
|
function isCoercibleUnderDoubleEquals(source, target) {
|
|
return (source.flags & (8 /* Number */ | 4 /* String */ | 512 /* BooleanLiteral */)) !== 0 && (target.flags & (8 /* Number */ | 4 /* String */ | 16 /* Boolean */)) !== 0;
|
|
}
|
|
function isObjectTypeWithInferableIndex(type) {
|
|
const objectFlags = getObjectFlags(type);
|
|
return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures2(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
|
|
}
|
|
function createSymbolWithType(source, type) {
|
|
const symbol = createSymbol(source.flags, source.escapedName, getCheckFlags(source) & 8 /* Readonly */);
|
|
symbol.declarations = source.declarations;
|
|
symbol.parent = source.parent;
|
|
symbol.type = type;
|
|
symbol.target = source;
|
|
if (source.valueDeclaration) {
|
|
symbol.valueDeclaration = source.valueDeclaration;
|
|
}
|
|
const nameType = getSymbolLinks(source).nameType;
|
|
if (nameType) {
|
|
symbol.nameType = nameType;
|
|
}
|
|
return symbol;
|
|
}
|
|
function transformTypeOfMembers(type, f) {
|
|
const members = createSymbolTable();
|
|
for (const property of getPropertiesOfObjectType(type)) {
|
|
const original = getTypeOfSymbol(property);
|
|
const updated = f(original);
|
|
members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
|
|
}
|
|
return members;
|
|
}
|
|
function getRegularTypeOfObjectLiteral(type) {
|
|
if (!(isObjectLiteralType(type) && getObjectFlags(type) & 8192 /* FreshLiteral */)) {
|
|
return type;
|
|
}
|
|
const regularType = type.regularType;
|
|
if (regularType) {
|
|
return regularType;
|
|
}
|
|
const resolved = type;
|
|
const members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
|
|
const regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.indexInfos);
|
|
regularNew.flags = resolved.flags;
|
|
regularNew.objectFlags |= resolved.objectFlags & ~8192 /* FreshLiteral */;
|
|
type.regularType = regularNew;
|
|
return regularNew;
|
|
}
|
|
function createWideningContext(parent, propertyName, siblings) {
|
|
return { parent, propertyName, siblings, resolvedProperties: void 0 };
|
|
}
|
|
function getSiblingsOfContext(context) {
|
|
if (!context.siblings) {
|
|
const siblings = [];
|
|
for (const type of getSiblingsOfContext(context.parent)) {
|
|
if (isObjectLiteralType(type)) {
|
|
const prop = getPropertyOfObjectType(type, context.propertyName);
|
|
if (prop) {
|
|
forEachType(getTypeOfSymbol(prop), (t) => {
|
|
siblings.push(t);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
context.siblings = siblings;
|
|
}
|
|
return context.siblings;
|
|
}
|
|
function getPropertiesOfContext(context) {
|
|
if (!context.resolvedProperties) {
|
|
const names = /* @__PURE__ */ new Map();
|
|
for (const t of getSiblingsOfContext(context)) {
|
|
if (isObjectLiteralType(t) && !(getObjectFlags(t) & 2097152 /* ContainsSpread */)) {
|
|
for (const prop of getPropertiesOfType(t)) {
|
|
names.set(prop.escapedName, prop);
|
|
}
|
|
}
|
|
}
|
|
context.resolvedProperties = arrayFrom(names.values());
|
|
}
|
|
return context.resolvedProperties;
|
|
}
|
|
function getWidenedProperty(prop, context) {
|
|
if (!(prop.flags & 4 /* Property */)) {
|
|
return prop;
|
|
}
|
|
const original = getTypeOfSymbol(prop);
|
|
const propContext = context && createWideningContext(context, prop.escapedName, void 0);
|
|
const widened = getWidenedTypeWithContext(original, propContext);
|
|
return widened === original ? prop : createSymbolWithType(prop, widened);
|
|
}
|
|
function getUndefinedProperty(prop) {
|
|
const cached = undefinedProperties.get(prop.escapedName);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
const result = createSymbolWithType(prop, missingType);
|
|
result.flags |= 16777216 /* Optional */;
|
|
undefinedProperties.set(prop.escapedName, result);
|
|
return result;
|
|
}
|
|
function getWidenedTypeOfObjectLiteral(type, context) {
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfObjectType(type)) {
|
|
members.set(prop.escapedName, getWidenedProperty(prop, context));
|
|
}
|
|
if (context) {
|
|
for (const prop of getPropertiesOfContext(context)) {
|
|
if (!members.has(prop.escapedName)) {
|
|
members.set(prop.escapedName, getUndefinedProperty(prop));
|
|
}
|
|
}
|
|
}
|
|
const result = createAnonymousType(
|
|
type.symbol,
|
|
members,
|
|
emptyArray,
|
|
emptyArray,
|
|
sameMap(getIndexInfosOfType(type), (info) => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly))
|
|
);
|
|
result.objectFlags |= getObjectFlags(type) & (4096 /* JSLiteral */ | 262144 /* NonInferrableType */);
|
|
return result;
|
|
}
|
|
function getWidenedType(type) {
|
|
return getWidenedTypeWithContext(type, void 0);
|
|
}
|
|
function getWidenedTypeWithContext(type, context) {
|
|
if (getObjectFlags(type) & 196608 /* RequiresWidening */) {
|
|
if (context === void 0 && type.widened) {
|
|
return type.widened;
|
|
}
|
|
let result;
|
|
if (type.flags & (1 /* Any */ | 98304 /* Nullable */)) {
|
|
result = anyType;
|
|
} else if (isObjectLiteralType(type)) {
|
|
result = getWidenedTypeOfObjectLiteral(type, context);
|
|
} else if (type.flags & 1048576 /* Union */) {
|
|
const unionContext = context || createWideningContext(void 0, void 0, type.types);
|
|
const widenedTypes = sameMap(type.types, (t) => t.flags & 98304 /* Nullable */ ? t : getWidenedTypeWithContext(t, unionContext));
|
|
result = getUnionType(widenedTypes, some(widenedTypes, isEmptyObjectType) ? 2 /* Subtype */ : 1 /* Literal */);
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
result = getIntersectionType(sameMap(type.types, getWidenedType));
|
|
} else if (isArrayOrTupleType(type)) {
|
|
result = createTypeReference(type.target, sameMap(getTypeArguments(type), getWidenedType));
|
|
}
|
|
if (result && context === void 0) {
|
|
type.widened = result;
|
|
}
|
|
return result || type;
|
|
}
|
|
return type;
|
|
}
|
|
function reportWideningErrorsInType(type) {
|
|
let errorReported = false;
|
|
if (getObjectFlags(type) & 65536 /* ContainsWideningType */) {
|
|
if (type.flags & 1048576 /* Union */) {
|
|
if (some(type.types, isEmptyObjectType)) {
|
|
errorReported = true;
|
|
} else {
|
|
for (const t of type.types) {
|
|
if (reportWideningErrorsInType(t)) {
|
|
errorReported = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isArrayOrTupleType(type)) {
|
|
for (const t of getTypeArguments(type)) {
|
|
if (reportWideningErrorsInType(t)) {
|
|
errorReported = true;
|
|
}
|
|
}
|
|
}
|
|
if (isObjectLiteralType(type)) {
|
|
for (const p of getPropertiesOfObjectType(type)) {
|
|
const t = getTypeOfSymbol(p);
|
|
if (getObjectFlags(t) & 65536 /* ContainsWideningType */) {
|
|
if (!reportWideningErrorsInType(t)) {
|
|
error(p.valueDeclaration, 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) {
|
|
const typeAsString = typeToString(getWidenedType(type));
|
|
if (isInJSFile(declaration) && !isCheckJsEnabledForFile(getSourceFileOfNode(declaration), compilerOptions)) {
|
|
return;
|
|
}
|
|
let diagnostic;
|
|
switch (declaration.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
diagnostic = noImplicitAny ? Diagnostics.Member_0_implicitly_has_an_1_type : Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
break;
|
|
case 166 /* Parameter */:
|
|
const param = declaration;
|
|
if (isIdentifier(param.name) && (isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) && param.parent.parameters.indexOf(param) > -1 && (resolveName(param, param.name.escapedText, 788968 /* Type */, void 0, param.name.escapedText, true) || param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
|
|
const newName = "arg" + param.parent.parameters.indexOf(param);
|
|
const typeName = declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
|
|
errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
|
|
return;
|
|
}
|
|
diagnostic = declaration.dotDotDotToken ? noImplicitAny ? Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage : noImplicitAny ? Diagnostics.Parameter_0_implicitly_has_an_1_type : Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
diagnostic = Diagnostics.Binding_element_0_implicitly_has_an_1_type;
|
|
if (!noImplicitAny) {
|
|
return;
|
|
}
|
|
break;
|
|
case 320 /* JSDocFunctionType */:
|
|
error(declaration, Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
|
|
return;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (noImplicitAny && !declaration.name) {
|
|
if (wideningKind === 3 /* GeneratorYield */) {
|
|
error(declaration, Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString);
|
|
} else {
|
|
error(declaration, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
|
|
}
|
|
return;
|
|
}
|
|
diagnostic = !noImplicitAny ? Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage : wideningKind === 3 /* GeneratorYield */ ? Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type : Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
|
|
break;
|
|
case 197 /* MappedType */:
|
|
if (noImplicitAny) {
|
|
error(declaration, Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type);
|
|
}
|
|
return;
|
|
default:
|
|
diagnostic = noImplicitAny ? Diagnostics.Variable_0_implicitly_has_an_1_type : Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
}
|
|
errorOrSuggestion(noImplicitAny, declaration, diagnostic, declarationNameToString(getNameOfDeclaration(declaration)), typeAsString);
|
|
}
|
|
function reportErrorsFromWidening(declaration, type, wideningKind) {
|
|
addLazyDiagnostic(() => {
|
|
if (noImplicitAny && getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
|
|
if (!reportWideningErrorsInType(type)) {
|
|
reportImplicitAny(declaration, type, wideningKind);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function applyToParameterTypes(source, target, callback) {
|
|
const sourceCount = getParameterCount(source);
|
|
const targetCount = getParameterCount(target);
|
|
const sourceRestType = getEffectiveRestType(source);
|
|
const targetRestType = getEffectiveRestType(target);
|
|
const targetNonRestCount = targetRestType ? targetCount - 1 : targetCount;
|
|
const paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount);
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
callback(sourceThisType, targetThisType);
|
|
}
|
|
}
|
|
for (let i = 0; i < paramCount; i++) {
|
|
callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i));
|
|
}
|
|
if (targetRestType) {
|
|
callback(getRestTypeAtPosition(source, paramCount), targetRestType);
|
|
}
|
|
}
|
|
function applyToReturnTypes(source, target, callback) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
const 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 = 0) {
|
|
return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
|
|
}
|
|
function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
|
|
const context = {
|
|
inferences,
|
|
signature,
|
|
flags,
|
|
compareTypes,
|
|
mapper: reportUnmeasurableMapper,
|
|
nonFixingMapper: reportUnmeasurableMapper
|
|
};
|
|
context.mapper = makeFixingMapperForContext(context);
|
|
context.nonFixingMapper = makeNonFixingMapperForContext(context);
|
|
return context;
|
|
}
|
|
function makeFixingMapperForContext(context) {
|
|
return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference, i) => () => {
|
|
if (!inference.isFixed) {
|
|
inferFromIntraExpressionSites(context);
|
|
clearCachedInferences(context.inferences);
|
|
inference.isFixed = true;
|
|
}
|
|
return getInferredType(context, i);
|
|
}));
|
|
}
|
|
function makeNonFixingMapperForContext(context) {
|
|
return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (_, i) => () => {
|
|
return getInferredType(context, i);
|
|
}));
|
|
}
|
|
function clearCachedInferences(inferences) {
|
|
for (const inference of inferences) {
|
|
if (!inference.isFixed) {
|
|
inference.inferredType = void 0;
|
|
}
|
|
}
|
|
}
|
|
function addIntraExpressionInferenceSite(context, node, type) {
|
|
var _a2;
|
|
((_a2 = context.intraExpressionInferenceSites) != null ? _a2 : context.intraExpressionInferenceSites = []).push({ node, type });
|
|
}
|
|
function inferFromIntraExpressionSites(context) {
|
|
if (context.intraExpressionInferenceSites) {
|
|
for (const { node, type } of context.intraExpressionInferenceSites) {
|
|
const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
|
|
if (contextualType) {
|
|
inferTypes(context.inferences, type, contextualType);
|
|
}
|
|
}
|
|
context.intraExpressionInferenceSites = void 0;
|
|
}
|
|
}
|
|
function createInferenceInfo(typeParameter) {
|
|
return {
|
|
typeParameter,
|
|
candidates: void 0,
|
|
contraCandidates: void 0,
|
|
inferredType: void 0,
|
|
priority: void 0,
|
|
topLevel: true,
|
|
isFixed: false,
|
|
impliedArity: void 0
|
|
};
|
|
}
|
|
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) {
|
|
const inferences = filter(context.inferences, hasInferenceCandidates);
|
|
return inferences.length ? createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : void 0;
|
|
}
|
|
function getMapperFromContext(context) {
|
|
return context && context.mapper;
|
|
}
|
|
function couldContainTypeVariables(type) {
|
|
const objectFlags = getObjectFlags(type);
|
|
if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
|
|
return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
|
|
}
|
|
const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || forEach(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
|
|
if (type.flags & 3899393 /* ObjectFlagsType */) {
|
|
type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
|
|
}
|
|
return result;
|
|
}
|
|
function isNonGenericTopLevelType(type) {
|
|
if (type.aliasSymbol && !type.aliasTypeArguments) {
|
|
const declaration = getDeclarationOfKind(type.aliasSymbol, 262 /* TypeAliasDeclaration */);
|
|
return !!(declaration && findAncestor(declaration.parent, (n) => n.kind === 308 /* SourceFile */ ? true : n.kind === 264 /* ModuleDeclaration */ ? false : "quit"));
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeParameterAtTopLevel(type, typeParameter) {
|
|
return !!(type === typeParameter || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isTypeParameterAtTopLevel(t, typeParameter)) || type.flags & 16777216 /* Conditional */ && (getTrueTypeFromConditionalType(type) === typeParameter || getFalseTypeFromConditionalType(type) === typeParameter));
|
|
}
|
|
function createEmptyObjectTypeFromStringLiteral(type) {
|
|
const members = createSymbolTable();
|
|
forEachType(type, (t) => {
|
|
if (!(t.flags & 128 /* StringLiteral */)) {
|
|
return;
|
|
}
|
|
const name = escapeLeadingUnderscores(t.value);
|
|
const literalProp = createSymbol(4 /* Property */, name);
|
|
literalProp.type = anyType;
|
|
if (t.symbol) {
|
|
literalProp.declarations = t.symbol.declarations;
|
|
literalProp.valueDeclaration = t.symbol.valueDeclaration;
|
|
}
|
|
members.set(name, literalProp);
|
|
});
|
|
const indexInfos = type.flags & 4 /* String */ ? [createIndexInfo(stringType, emptyObjectType, false)] : emptyArray;
|
|
return createAnonymousType(void 0, members, emptyArray, emptyArray, indexInfos);
|
|
}
|
|
function inferTypeForHomomorphicMappedType(source, target, constraint) {
|
|
if (inInferTypeForHomomorphicMappedType) {
|
|
return void 0;
|
|
}
|
|
const key = source.id + "," + target.id + "," + constraint.id;
|
|
if (reverseMappedCache.has(key)) {
|
|
return reverseMappedCache.get(key);
|
|
}
|
|
inInferTypeForHomomorphicMappedType = true;
|
|
const type = createReverseMappedType(source, target, constraint);
|
|
inInferTypeForHomomorphicMappedType = false;
|
|
reverseMappedCache.set(key, type);
|
|
return type;
|
|
}
|
|
function isPartiallyInferableType(type) {
|
|
return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getTypeArguments(type), isPartiallyInferableType);
|
|
}
|
|
function createReverseMappedType(source, target, constraint) {
|
|
if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
|
|
return void 0;
|
|
}
|
|
if (isArrayType(source)) {
|
|
return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
|
|
}
|
|
if (isTupleType(source)) {
|
|
const elementTypes = map(getTypeArguments(source), (t) => inferReverseMappedType(t, target, constraint));
|
|
const elementFlags = getMappedTypeModifiers(target) & 4 /* IncludeOptional */ ? sameMap(source.target.elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : source.target.elementFlags;
|
|
return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
|
|
}
|
|
const reversed = createObjectType(1024 /* ReverseMapped */ | 16 /* Anonymous */, void 0);
|
|
reversed.source = source;
|
|
reversed.mappedType = target;
|
|
reversed.constraintType = constraint;
|
|
return reversed;
|
|
}
|
|
function getTypeOfReverseMappedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
links.type = inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType);
|
|
}
|
|
return links.type;
|
|
}
|
|
function inferReverseMappedType(sourceType, target, constraint) {
|
|
const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
|
|
const templateType = getTemplateTypeFromMappedType(target);
|
|
const inference = createInferenceInfo(typeParameter);
|
|
inferTypes([inference], sourceType, templateType);
|
|
return getTypeFromInference(inference) || unknownType;
|
|
}
|
|
function* getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
|
|
const properties = getPropertiesOfType(target);
|
|
for (const targetProp of properties) {
|
|
if (isStaticPrivateIdentifierProperty(targetProp)) {
|
|
continue;
|
|
}
|
|
if (requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */ || getCheckFlags(targetProp) & 48 /* Partial */)) {
|
|
const sourceProp = getPropertyOfType(source, targetProp.escapedName);
|
|
if (!sourceProp) {
|
|
yield targetProp;
|
|
} else if (matchDiscriminantProperties) {
|
|
const targetType = getTypeOfSymbol(targetProp);
|
|
if (targetType.flags & 109440 /* Unit */) {
|
|
const sourceType = getTypeOfSymbol(sourceProp);
|
|
if (!(sourceType.flags & 1 /* Any */ || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) {
|
|
yield targetProp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) {
|
|
const result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next();
|
|
if (!result.done)
|
|
return result.value;
|
|
}
|
|
function tupleTypesDefinitelyUnrelated(source, target) {
|
|
return !(target.target.combinedFlags & 8 /* Variadic */) && target.target.minLength > source.target.minLength || !target.target.hasRestElement && (source.target.hasRestElement || target.target.fixedLength < source.target.fixedLength);
|
|
}
|
|
function typesDefinitelyUnrelated(source, target) {
|
|
return isTupleType(source) && isTupleType(target) ? tupleTypesDefinitelyUnrelated(source, target) : !!getUnmatchedProperty(source, target, false, true) && !!getUnmatchedProperty(target, source, false, false);
|
|
}
|
|
function getTypeFromInference(inference) {
|
|
return inference.candidates ? getUnionType(inference.candidates, 2 /* Subtype */) : inference.contraCandidates ? getIntersectionType(inference.contraCandidates) : void 0;
|
|
}
|
|
function hasSkipDirectInferenceFlag(node) {
|
|
return !!getNodeLinks(node).skipDirectInference;
|
|
}
|
|
function isFromInferenceBlockedSource(type) {
|
|
return !!(type.symbol && some(type.symbol.declarations, hasSkipDirectInferenceFlag));
|
|
}
|
|
function templateLiteralTypesDefinitelyUnrelated(source, target) {
|
|
const sourceStart = source.texts[0];
|
|
const targetStart = target.texts[0];
|
|
const sourceEnd = source.texts[source.texts.length - 1];
|
|
const targetEnd = target.texts[target.texts.length - 1];
|
|
const startLen = Math.min(sourceStart.length, targetStart.length);
|
|
const 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);
|
|
}
|
|
function isValidNumberString(s, roundTripOnly) {
|
|
if (s === "")
|
|
return false;
|
|
const n = +s;
|
|
return isFinite(n) && (!roundTripOnly || "" + n === s);
|
|
}
|
|
function parseBigIntLiteralType(text) {
|
|
const negative = text.startsWith("-");
|
|
const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
|
|
return getBigIntLiteralType({ negative, base10Value });
|
|
}
|
|
function isValidBigIntString(s, roundTripOnly) {
|
|
if (s === "")
|
|
return false;
|
|
const scanner = createScanner(99 /* ESNext */, false);
|
|
let success = true;
|
|
scanner.setOnError(() => success = false);
|
|
scanner.setText(s + "n");
|
|
let result = scanner.scan();
|
|
const negative = result === 40 /* MinusToken */;
|
|
if (negative) {
|
|
result = scanner.scan();
|
|
}
|
|
const flags = scanner.getTokenFlags();
|
|
return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === s.length + 1 && !(flags & 512 /* ContainsSeparator */) && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner.getTokenValue()) }));
|
|
}
|
|
function isMemberOfStringMapping(source, target) {
|
|
if (target.flags & (4 /* String */ | 1 /* Any */)) {
|
|
return true;
|
|
}
|
|
if (target.flags & 134217728 /* TemplateLiteral */) {
|
|
return isTypeAssignableTo(source, target);
|
|
}
|
|
if (target.flags & 268435456 /* StringMapping */) {
|
|
const mappingStack = [];
|
|
while (target.flags & 268435456 /* StringMapping */) {
|
|
mappingStack.unshift(target.symbol);
|
|
target = target.type;
|
|
}
|
|
const mappedSource = reduceLeft(mappingStack, (memo, value) => getStringMappingType(value, memo), source);
|
|
return mappedSource === source && isMemberOfStringMapping(source, target);
|
|
}
|
|
return false;
|
|
}
|
|
function isValidTypeForTemplateLiteralPlaceholder(source, target) {
|
|
if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
|
|
return true;
|
|
}
|
|
if (source.flags & 128 /* StringLiteral */) {
|
|
const value = source.value;
|
|
return !!(target.flags & 8 /* Number */ && isValidNumberString(value, false) || target.flags & 64 /* BigInt */ && isValidBigIntString(value, false) || target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target));
|
|
}
|
|
if (source.flags & 134217728 /* TemplateLiteral */) {
|
|
const 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 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
|
|
}
|
|
function isTypeMatchedByTemplateLiteralType(source, target) {
|
|
const inferences = inferTypesFromTemplateLiteralType(source, target);
|
|
return !!inferences && every(inferences, (r, i) => isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]));
|
|
}
|
|
function getStringLikeTypeForType(type) {
|
|
return type.flags & (1 /* Any */ | 402653316 /* StringLike */) ? type : getTemplateLiteralType(["", ""], [type]);
|
|
}
|
|
function inferFromLiteralPartsToTemplateLiteral(sourceTexts, sourceTypes, target) {
|
|
const lastSourceIndex = sourceTexts.length - 1;
|
|
const sourceStartText = sourceTexts[0];
|
|
const sourceEndText = sourceTexts[lastSourceIndex];
|
|
const targetTexts = target.texts;
|
|
const lastTargetIndex = targetTexts.length - 1;
|
|
const targetStartText = targetTexts[0];
|
|
const targetEndText = targetTexts[lastTargetIndex];
|
|
if (lastSourceIndex === 0 && sourceStartText.length < targetStartText.length + targetEndText.length || !sourceStartText.startsWith(targetStartText) || !sourceEndText.endsWith(targetEndText))
|
|
return void 0;
|
|
const remainingEndText = sourceEndText.slice(0, sourceEndText.length - targetEndText.length);
|
|
const matches = [];
|
|
let seg = 0;
|
|
let pos = targetStartText.length;
|
|
for (let i = 1; i < lastTargetIndex; i++) {
|
|
const delim = targetTexts[i];
|
|
if (delim.length > 0) {
|
|
let s = seg;
|
|
let p = pos;
|
|
while (true) {
|
|
p = getSourceText(s).indexOf(delim, p);
|
|
if (p >= 0)
|
|
break;
|
|
s++;
|
|
if (s === sourceTexts.length)
|
|
return void 0;
|
|
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 void 0;
|
|
}
|
|
}
|
|
addMatch(lastSourceIndex, getSourceText(lastSourceIndex).length);
|
|
return matches;
|
|
function getSourceText(index) {
|
|
return index < lastSourceIndex ? sourceTexts[index] : remainingEndText;
|
|
}
|
|
function addMatch(s, p) {
|
|
const matchType = s === seg ? getStringLiteralType(getSourceText(s).slice(pos, p)) : getTemplateLiteralType(
|
|
[sourceTexts[seg].slice(pos), ...sourceTexts.slice(seg + 1, s), getSourceText(s).slice(0, p)],
|
|
sourceTypes.slice(seg, s)
|
|
);
|
|
matches.push(matchType);
|
|
seg = s;
|
|
pos = p;
|
|
}
|
|
}
|
|
function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
|
|
let bivariant = false;
|
|
let propagationType;
|
|
let inferencePriority = 2048 /* MaxValue */;
|
|
let allowComplexConstraintInference = true;
|
|
let visited;
|
|
let sourceStack;
|
|
let targetStack;
|
|
let expandingFlags = 0 /* None */;
|
|
inferFromTypes(originalSource, originalTarget);
|
|
function inferFromTypes(source, target) {
|
|
if (!couldContainTypeVariables(target)) {
|
|
return;
|
|
}
|
|
if (source === wildcardType) {
|
|
const savePropagationType = propagationType;
|
|
propagationType = source;
|
|
inferFromTypes(target, target);
|
|
propagationType = savePropagationType;
|
|
return;
|
|
}
|
|
if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
|
|
if (source.aliasTypeArguments) {
|
|
inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
|
|
}
|
|
return;
|
|
}
|
|
if (source === target && source.flags & 3145728 /* UnionOrIntersection */) {
|
|
for (const t of source.types) {
|
|
inferFromTypes(t, t);
|
|
}
|
|
return;
|
|
}
|
|
if (target.flags & 1048576 /* Union */) {
|
|
const [tempSources, tempTargets] = inferFromMatchingTypes(source.flags & 1048576 /* Union */ ? source.types : [source], target.types, isTypeOrBaseIdenticalTo);
|
|
const [sources, targets] = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy);
|
|
if (targets.length === 0) {
|
|
return;
|
|
}
|
|
target = getUnionType(targets);
|
|
if (sources.length === 0) {
|
|
inferWithPriority(source, target, 1 /* NakedTypeVariable */);
|
|
return;
|
|
}
|
|
source = getUnionType(sources);
|
|
} else if (target.flags & 2097152 /* Intersection */ && !every(target.types, isNonGenericObjectType)) {
|
|
if (!(source.flags & 1048576 /* Union */)) {
|
|
const [sources, targets] = inferFromMatchingTypes(source.flags & 2097152 /* Intersection */ ? source.types : [source], target.types, isTypeIdenticalTo);
|
|
if (sources.length === 0 || targets.length === 0) {
|
|
return;
|
|
}
|
|
source = getIntersectionType(sources);
|
|
target = getIntersectionType(targets);
|
|
}
|
|
} else if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
|
|
target = getActualTypeVariable(target);
|
|
}
|
|
if (target.flags & 8650752 /* TypeVariable */) {
|
|
if (isFromInferenceBlockedSource(source)) {
|
|
return;
|
|
}
|
|
const inference = getInferenceInfoForType(target);
|
|
if (inference) {
|
|
if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
|
|
return;
|
|
}
|
|
if (!inference.isFixed) {
|
|
if (inference.priority === void 0 || priority < inference.priority) {
|
|
inference.candidates = void 0;
|
|
inference.contraCandidates = void 0;
|
|
inference.topLevel = true;
|
|
inference.priority = priority;
|
|
}
|
|
if (priority === inference.priority) {
|
|
const candidate = propagationType || source;
|
|
if (contravariant && !bivariant) {
|
|
if (!contains(inference.contraCandidates, candidate)) {
|
|
inference.contraCandidates = append(inference.contraCandidates, candidate);
|
|
clearCachedInferences(inferences);
|
|
}
|
|
} else if (!contains(inference.candidates, candidate)) {
|
|
inference.candidates = append(inference.candidates, candidate);
|
|
clearCachedInferences(inferences);
|
|
}
|
|
}
|
|
if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
|
|
inference.topLevel = false;
|
|
clearCachedInferences(inferences);
|
|
}
|
|
}
|
|
inferencePriority = Math.min(inferencePriority, priority);
|
|
return;
|
|
}
|
|
const simplified = getSimplifiedType(target, false);
|
|
if (simplified !== target) {
|
|
inferFromTypes(source, simplified);
|
|
} else if (target.flags & 8388608 /* IndexedAccess */) {
|
|
const indexType = getSimplifiedType(target.indexType, false);
|
|
if (indexType.flags & 465829888 /* Instantiable */) {
|
|
const simplified2 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
|
|
if (simplified2 && simplified2 !== target) {
|
|
inferFromTypes(source, simplified2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target)) && !(source.node && target.node)) {
|
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
} else if (source.flags & 4194304 /* Index */ && target.flags & 4194304 /* Index */) {
|
|
inferFromContravariantTypes(source.type, target.type);
|
|
} else if ((isLiteralType(source) || source.flags & 4 /* String */) && target.flags & 4194304 /* Index */) {
|
|
const empty = createEmptyObjectTypeFromStringLiteral(source);
|
|
inferFromContravariantTypesWithPriority(empty, target.type, 256 /* LiteralKeyof */);
|
|
} else if (source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */) {
|
|
inferFromTypes(source.objectType, target.objectType);
|
|
inferFromTypes(source.indexType, target.indexType);
|
|
} else if (source.flags & 268435456 /* StringMapping */ && target.flags & 268435456 /* StringMapping */) {
|
|
if (source.symbol === target.symbol) {
|
|
inferFromTypes(source.type, target.type);
|
|
}
|
|
} else if (source.flags & 33554432 /* Substitution */) {
|
|
inferFromTypes(source.baseType, target);
|
|
inferWithPriority(getSubstitutionIntersection(source), target, 4 /* SubstituteSource */);
|
|
} else if (target.flags & 16777216 /* Conditional */) {
|
|
invokeOnce(source, target, inferToConditionalType);
|
|
} else if (target.flags & 3145728 /* UnionOrIntersection */) {
|
|
inferToMultipleTypes(source, target.types, target.flags);
|
|
} else if (source.flags & 1048576 /* Union */) {
|
|
const sourceTypes = source.types;
|
|
for (const sourceType of sourceTypes) {
|
|
inferFromTypes(sourceType, target);
|
|
}
|
|
} else if (target.flags & 134217728 /* TemplateLiteral */) {
|
|
inferToTemplateLiteralType(source, target);
|
|
} else {
|
|
source = getReducedType(source);
|
|
if (!(priority & 512 /* NoConstraints */ && source.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */))) {
|
|
const apparentSource = getApparentType(source);
|
|
if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 /* Object */ | 2097152 /* Intersection */))) {
|
|
allowComplexConstraintInference = false;
|
|
return inferFromTypes(apparentSource, target);
|
|
}
|
|
source = apparentSource;
|
|
}
|
|
if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */)) {
|
|
invokeOnce(source, target, inferFromObjectTypes);
|
|
}
|
|
}
|
|
}
|
|
function inferWithPriority(source, target, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferFromTypes(source, target);
|
|
priority = savePriority;
|
|
}
|
|
function inferFromContravariantTypesWithPriority(source, target, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferFromContravariantTypes(source, target);
|
|
priority = savePriority;
|
|
}
|
|
function inferToMultipleTypesWithPriority(source, targets, targetFlags, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferToMultipleTypes(source, targets, targetFlags);
|
|
priority = savePriority;
|
|
}
|
|
function invokeOnce(source, target, action) {
|
|
const key = source.id + "," + target.id;
|
|
const status = visited && visited.get(key);
|
|
if (status !== void 0) {
|
|
inferencePriority = Math.min(inferencePriority, status);
|
|
return;
|
|
}
|
|
(visited || (visited = /* @__PURE__ */ new Map())).set(key, -1 /* Circularity */);
|
|
const saveInferencePriority = inferencePriority;
|
|
inferencePriority = 2048 /* MaxValue */;
|
|
const saveExpandingFlags = expandingFlags;
|
|
const sourceIdentity = getRecursionIdentity(source);
|
|
const targetIdentity = getRecursionIdentity(target);
|
|
if (contains(sourceStack, sourceIdentity))
|
|
expandingFlags |= 1 /* Source */;
|
|
if (contains(targetStack, targetIdentity))
|
|
expandingFlags |= 2 /* Target */;
|
|
if (expandingFlags !== 3 /* Both */) {
|
|
(sourceStack || (sourceStack = [])).push(sourceIdentity);
|
|
(targetStack || (targetStack = [])).push(targetIdentity);
|
|
action(source, target);
|
|
targetStack.pop();
|
|
sourceStack.pop();
|
|
} else {
|
|
inferencePriority = -1 /* Circularity */;
|
|
}
|
|
expandingFlags = saveExpandingFlags;
|
|
visited.set(key, inferencePriority);
|
|
inferencePriority = Math.min(inferencePriority, saveInferencePriority);
|
|
}
|
|
function inferFromMatchingTypes(sources, targets, matches) {
|
|
let matchedSources;
|
|
let matchedTargets;
|
|
for (const t of targets) {
|
|
for (const s of sources) {
|
|
if (matches(s, t)) {
|
|
inferFromTypes(s, t);
|
|
matchedSources = appendIfUnique(matchedSources, s);
|
|
matchedTargets = appendIfUnique(matchedTargets, t);
|
|
}
|
|
}
|
|
}
|
|
return [
|
|
matchedSources ? filter(sources, (t) => !contains(matchedSources, t)) : sources,
|
|
matchedTargets ? filter(targets, (t) => !contains(matchedTargets, t)) : targets
|
|
];
|
|
}
|
|
function inferFromTypeArguments(sourceTypes, targetTypes, variances) {
|
|
const count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
|
|
for (let i = 0; i < count; i++) {
|
|
if (i < variances.length && (variances[i] & 7 /* VarianceMask */) === 2 /* 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 /* AlwaysStrict */) {
|
|
inferFromContravariantTypes(source, target);
|
|
} else {
|
|
inferFromTypes(source, target);
|
|
}
|
|
}
|
|
function getInferenceInfoForType(type) {
|
|
if (type.flags & 8650752 /* TypeVariable */) {
|
|
for (const inference of inferences) {
|
|
if (type === inference.typeParameter) {
|
|
return inference;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSingleTypeVariableFromIntersectionTypes(types) {
|
|
let typeVariable;
|
|
for (const type of types) {
|
|
const t = type.flags & 2097152 /* Intersection */ && find(type.types, (t2) => !!getInferenceInfoForType(t2));
|
|
if (!t || typeVariable && t !== typeVariable) {
|
|
return void 0;
|
|
}
|
|
typeVariable = t;
|
|
}
|
|
return typeVariable;
|
|
}
|
|
function inferToMultipleTypes(source, targets, targetFlags) {
|
|
let typeVariableCount = 0;
|
|
if (targetFlags & 1048576 /* Union */) {
|
|
let nakedTypeVariable;
|
|
const sources = source.flags & 1048576 /* Union */ ? source.types : [source];
|
|
const matched = new Array(sources.length);
|
|
let inferenceCircularity = false;
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
nakedTypeVariable = t;
|
|
typeVariableCount++;
|
|
} else {
|
|
for (let i = 0; i < sources.length; i++) {
|
|
const saveInferencePriority = inferencePriority;
|
|
inferencePriority = 2048 /* MaxValue */;
|
|
inferFromTypes(sources[i], t);
|
|
if (inferencePriority === priority)
|
|
matched[i] = true;
|
|
inferenceCircularity = inferenceCircularity || inferencePriority === -1 /* Circularity */;
|
|
inferencePriority = Math.min(inferencePriority, saveInferencePriority);
|
|
}
|
|
}
|
|
}
|
|
if (typeVariableCount === 0) {
|
|
const intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets);
|
|
if (intersectionTypeVariable) {
|
|
inferWithPriority(source, intersectionTypeVariable, 1 /* NakedTypeVariable */);
|
|
}
|
|
return;
|
|
}
|
|
if (typeVariableCount === 1 && !inferenceCircularity) {
|
|
const unmatched = flatMap(sources, (s, i) => matched[i] ? void 0 : s);
|
|
if (unmatched.length) {
|
|
inferFromTypes(getUnionType(unmatched), nakedTypeVariable);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
typeVariableCount++;
|
|
} else {
|
|
inferFromTypes(source, t);
|
|
}
|
|
}
|
|
}
|
|
if (targetFlags & 2097152 /* Intersection */ ? typeVariableCount === 1 : typeVariableCount > 0) {
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
inferWithPriority(source, t, 1 /* NakedTypeVariable */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function inferToMappedType(source, target, constraintType) {
|
|
if (constraintType.flags & 1048576 /* Union */) {
|
|
let result = false;
|
|
for (const type of constraintType.types) {
|
|
result = inferToMappedType(source, target, type) || result;
|
|
}
|
|
return result;
|
|
}
|
|
if (constraintType.flags & 4194304 /* Index */) {
|
|
const inference = getInferenceInfoForType(constraintType.type);
|
|
if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) {
|
|
const inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType);
|
|
if (inferredType) {
|
|
inferWithPriority(
|
|
inferredType,
|
|
inference.typeParameter,
|
|
getObjectFlags(source) & 262144 /* NonInferrableType */ ? 16 /* PartialHomomorphicMappedType */ : 8 /* HomomorphicMappedType */
|
|
);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (constraintType.flags & 262144 /* TypeParameter */) {
|
|
inferWithPriority(getIndexType(source), constraintType, 32 /* MappedTypeConstraint */);
|
|
const extendedConstraint = getConstraintOfType(constraintType);
|
|
if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
|
|
return true;
|
|
}
|
|
const propTypes = map(getPropertiesOfType(source), getTypeOfSymbol);
|
|
const indexTypes = map(getIndexInfosOfType(source), (info) => info !== enumNumberIndexInfo ? info.type : neverType);
|
|
inferFromTypes(getUnionType(concatenate(propTypes, indexTypes)), getTemplateTypeFromMappedType(target));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function inferToConditionalType(source, target) {
|
|
if (source.flags & 16777216 /* Conditional */) {
|
|
inferFromTypes(source.checkType, target.checkType);
|
|
inferFromTypes(source.extendsType, target.extendsType);
|
|
inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target));
|
|
inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target));
|
|
} else {
|
|
const targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)];
|
|
inferToMultipleTypesWithPriority(source, targetTypes, target.flags, contravariant ? 64 /* ContravariantConditional */ : 0);
|
|
}
|
|
}
|
|
function inferToTemplateLiteralType(source, target) {
|
|
const matches = inferTypesFromTemplateLiteralType(source, target);
|
|
const types = target.types;
|
|
if (matches || every(target.texts, (s) => s.length === 0)) {
|
|
for (let i = 0; i < types.length; i++) {
|
|
const source2 = matches ? matches[i] : neverType;
|
|
const target2 = types[i];
|
|
if (source2.flags & 128 /* StringLiteral */ && target2.flags & 8650752 /* TypeVariable */) {
|
|
const inferenceContext = getInferenceInfoForType(target2);
|
|
const constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : void 0;
|
|
if (constraint && !isTypeAny(constraint)) {
|
|
const constraintTypes = constraint.flags & 1048576 /* Union */ ? constraint.types : [constraint];
|
|
let allTypeFlags = reduceLeft(constraintTypes, (flags, t) => flags | t.flags, 0);
|
|
if (!(allTypeFlags & 4 /* String */)) {
|
|
const str = source2.value;
|
|
if (allTypeFlags & 296 /* NumberLike */ && !isValidNumberString(str, true)) {
|
|
allTypeFlags &= ~296 /* NumberLike */;
|
|
}
|
|
if (allTypeFlags & 2112 /* BigIntLike */ && !isValidBigIntString(str, true)) {
|
|
allTypeFlags &= ~2112 /* BigIntLike */;
|
|
}
|
|
const matchingType = reduceLeft(
|
|
constraintTypes,
|
|
(left, right) => !(right.flags & allTypeFlags) ? left : left.flags & 4 /* String */ ? left : right.flags & 4 /* String */ ? source2 : left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source2, right) ? source2 : left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str === applyStringMapping(right.symbol, str) ? source2 : left.flags & 128 /* StringLiteral */ ? left : right.flags & 128 /* StringLiteral */ && right.value === str ? right : left.flags & 8 /* Number */ ? left : right.flags & 8 /* Number */ ? getNumberLiteralType(+str) : left.flags & 32 /* Enum */ ? left : right.flags & 32 /* Enum */ ? getNumberLiteralType(+str) : left.flags & 256 /* NumberLiteral */ ? left : right.flags & 256 /* NumberLiteral */ && right.value === +str ? right : left.flags & 64 /* BigInt */ ? left : right.flags & 64 /* BigInt */ ? parseBigIntLiteralType(str) : left.flags & 2048 /* BigIntLiteral */ ? left : right.flags & 2048 /* BigIntLiteral */ && pseudoBigIntToString(right.value) === str ? right : left.flags & 16 /* Boolean */ ? left : right.flags & 16 /* Boolean */ ? str === "true" ? trueType : str === "false" ? falseType : booleanType : left.flags & 512 /* BooleanLiteral */ ? left : right.flags & 512 /* BooleanLiteral */ && right.intrinsicName === str ? right : left.flags & 32768 /* Undefined */ ? left : right.flags & 32768 /* Undefined */ && right.intrinsicName === str ? right : left.flags & 65536 /* Null */ ? left : right.flags & 65536 /* Null */ && right.intrinsicName === str ? right : left,
|
|
neverType
|
|
);
|
|
if (!(matchingType.flags & 131072 /* Never */)) {
|
|
inferFromTypes(matchingType, target2);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
inferFromTypes(source2, target2);
|
|
}
|
|
}
|
|
}
|
|
function inferFromObjectTypes(source, target) {
|
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
return;
|
|
}
|
|
if (isGenericMappedType(source) && isGenericMappedType(target)) {
|
|
inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target));
|
|
inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target));
|
|
const sourceNameType = getNameTypeFromMappedType(source);
|
|
const targetNameType = getNameTypeFromMappedType(target);
|
|
if (sourceNameType && targetNameType)
|
|
inferFromTypes(sourceNameType, targetNameType);
|
|
}
|
|
if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
|
|
const constraintType = getConstraintTypeFromMappedType(target);
|
|
if (inferToMappedType(source, target, constraintType)) {
|
|
return;
|
|
}
|
|
}
|
|
if (!typesDefinitelyUnrelated(source, target)) {
|
|
if (isArrayOrTupleType(source)) {
|
|
if (isTupleType(target)) {
|
|
const sourceArity = getTypeReferenceArity(source);
|
|
const targetArity = getTypeReferenceArity(target);
|
|
const elementTypes = getTypeArguments(target);
|
|
const elementFlags = target.target.elementFlags;
|
|
if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
|
|
for (let i = 0; i < targetArity; i++) {
|
|
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
|
|
}
|
|
return;
|
|
}
|
|
const startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0;
|
|
const endLength = Math.min(
|
|
isTupleType(source) ? getEndElementCount(source.target, 3 /* Fixed */) : 0,
|
|
target.target.hasRestElement ? getEndElementCount(target.target, 3 /* Fixed */) : 0
|
|
);
|
|
for (let i = 0; i < startLength; i++) {
|
|
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
|
|
}
|
|
if (!isTupleType(source) || sourceArity - startLength - endLength === 1 && source.target.elementFlags[startLength] & 4 /* Rest */) {
|
|
const restType = getTypeArguments(source)[startLength];
|
|
for (let i = startLength; i < targetArity - endLength; i++) {
|
|
inferFromTypes(elementFlags[i] & 8 /* Variadic */ ? createArrayType(restType) : restType, elementTypes[i]);
|
|
}
|
|
} else {
|
|
const middleLength = targetArity - startLength - endLength;
|
|
if (middleLength === 2 && elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
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 /* Variadic */) {
|
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
|
const sourceSlice = isTupleType(source) ? sliceTupleType(source, startLength, endLength) : createArrayType(getTypeArguments(source)[0]);
|
|
inferWithPriority(sourceSlice, elementTypes[startLength], endsInOptional ? 2 /* SpeculativeTuple */ : 0);
|
|
} else if (middleLength === 1 && elementFlags[startLength] & 4 /* Rest */) {
|
|
const restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, endLength) : getTypeArguments(source)[0];
|
|
if (restType) {
|
|
inferFromTypes(restType, elementTypes[startLength]);
|
|
}
|
|
}
|
|
}
|
|
for (let 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 /* Call */);
|
|
inferFromSignatures(source, target, 1 /* Construct */);
|
|
inferFromIndexTypes(source, target);
|
|
}
|
|
}
|
|
function inferFromProperties(source, target) {
|
|
const properties = getPropertiesOfObjectType(target);
|
|
for (const targetProp of properties) {
|
|
const sourceProp = getPropertyOfType(source, targetProp.escapedName);
|
|
if (sourceProp && !some(sourceProp.declarations, hasSkipDirectInferenceFlag)) {
|
|
inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
|
|
}
|
|
}
|
|
}
|
|
function inferFromSignatures(source, target, kind) {
|
|
const sourceSignatures = getSignaturesOfType(source, kind);
|
|
const targetSignatures = getSignaturesOfType(target, kind);
|
|
const sourceLen = sourceSignatures.length;
|
|
const targetLen = targetSignatures.length;
|
|
const len = sourceLen < targetLen ? sourceLen : targetLen;
|
|
for (let i = 0; i < len; i++) {
|
|
inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
|
|
}
|
|
}
|
|
function inferFromSignature(source, target) {
|
|
const saveBivariant = bivariant;
|
|
const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
|
|
bivariant = bivariant || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 173 /* Constructor */;
|
|
applyToParameterTypes(source, target, inferFromContravariantTypesIfStrictFunctionTypes);
|
|
bivariant = saveBivariant;
|
|
applyToReturnTypes(source, target, inferFromTypes);
|
|
}
|
|
function inferFromIndexTypes(source, target) {
|
|
const priority2 = getObjectFlags(source) & getObjectFlags(target) & 32 /* Mapped */ ? 8 /* HomomorphicMappedType */ : 0;
|
|
const indexInfos = getIndexInfosOfType(target);
|
|
if (isObjectTypeWithInferableIndex(source)) {
|
|
for (const targetInfo of indexInfos) {
|
|
const propTypes = [];
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), targetInfo.keyType)) {
|
|
const propType = getTypeOfSymbol(prop);
|
|
propTypes.push(prop.flags & 16777216 /* Optional */ ? removeMissingOrUndefinedType(propType) : propType);
|
|
}
|
|
}
|
|
for (const info of getIndexInfosOfType(source)) {
|
|
if (isApplicableIndexType(info.keyType, targetInfo.keyType)) {
|
|
propTypes.push(info.type);
|
|
}
|
|
}
|
|
if (propTypes.length) {
|
|
inferWithPriority(getUnionType(propTypes), targetInfo.type, priority2);
|
|
}
|
|
}
|
|
}
|
|
for (const targetInfo of indexInfos) {
|
|
const sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType);
|
|
if (sourceInfo) {
|
|
inferWithPriority(sourceInfo.type, targetInfo.type, priority2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isTypeOrBaseIdenticalTo(s, t) {
|
|
return exactOptionalPropertyTypes && t === missingType ? s === t : isTypeIdenticalTo(s, t) || !!(t.flags & 4 /* String */ && s.flags & 128 /* StringLiteral */ || t.flags & 8 /* Number */ && s.flags & 256 /* NumberLiteral */);
|
|
}
|
|
function isTypeCloselyMatchedBy(s, t) {
|
|
return !!(s.flags & 524288 /* Object */ && t.flags & 524288 /* Object */ && s.symbol && s.symbol === t.symbol || s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol);
|
|
}
|
|
function hasPrimitiveConstraint(type) {
|
|
const constraint = getConstraintOfTypeParameter(type);
|
|
return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
|
|
}
|
|
function isObjectLiteralType(type) {
|
|
return !!(getObjectFlags(type) & 128 /* ObjectLiteral */);
|
|
}
|
|
function isObjectOrArrayLiteralType(type) {
|
|
return !!(getObjectFlags(type) & (128 /* ObjectLiteral */ | 16384 /* ArrayLiteral */));
|
|
}
|
|
function unionObjectAndArrayLiteralCandidates(candidates) {
|
|
if (candidates.length > 1) {
|
|
const objectLiterals = filter(candidates, isObjectOrArrayLiteralType);
|
|
if (objectLiterals.length) {
|
|
const literalsType = getUnionType(objectLiterals, 2 /* Subtype */);
|
|
return concatenate(filter(candidates, (t) => !isObjectOrArrayLiteralType(t)), [literalsType]);
|
|
}
|
|
}
|
|
return candidates;
|
|
}
|
|
function getContravariantInference(inference) {
|
|
return inference.priority & 416 /* PriorityImpliesCombination */ ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates);
|
|
}
|
|
function getCovariantInference(inference, signature) {
|
|
const candidates = unionObjectAndArrayLiteralCandidates(inference.candidates);
|
|
const primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter);
|
|
const widenLiteralTypes = !primitiveConstraint && inference.topLevel && (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter));
|
|
const baseCandidates = primitiveConstraint ? sameMap(candidates, getRegularTypeOfLiteralType) : widenLiteralTypes ? sameMap(candidates, getWidenedLiteralType) : candidates;
|
|
const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
|
|
return getWidenedType(unwidenedType);
|
|
}
|
|
function getInferredType(context, index) {
|
|
const inference = context.inferences[index];
|
|
if (!inference.inferredType) {
|
|
let inferredType;
|
|
const signature = context.signature;
|
|
if (signature) {
|
|
const inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : void 0;
|
|
if (inference.contraCandidates) {
|
|
inferredType = inferredCovariantType && !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) ? inferredCovariantType : getContravariantInference(inference);
|
|
} else if (inferredCovariantType) {
|
|
inferredType = inferredCovariantType;
|
|
} else if (context.flags & 1 /* NoDefault */) {
|
|
inferredType = silentNeverType;
|
|
} else {
|
|
const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
|
|
if (defaultType) {
|
|
inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
|
|
}
|
|
}
|
|
} else {
|
|
inferredType = getTypeFromInference(inference);
|
|
}
|
|
inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2 /* AnyDefault */));
|
|
const constraint = getConstraintOfTypeParameter(inference.typeParameter);
|
|
if (constraint) {
|
|
const 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) {
|
|
const result = [];
|
|
for (let i = 0; i < context.inferences.length; i++) {
|
|
result.push(getInferredType(context, i));
|
|
}
|
|
return result;
|
|
}
|
|
function getCannotFindNameDiagnosticForName(node) {
|
|
switch (node.escapedText) {
|
|
case "document":
|
|
case "console":
|
|
return 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 ? 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 : 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 ? 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 : 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 ? 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 : 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 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 (isCallExpression(node.parent)) {
|
|
return Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function;
|
|
}
|
|
default:
|
|
if (node.parent.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
|
|
} else {
|
|
return Diagnostics.Cannot_find_name_0;
|
|
}
|
|
}
|
|
}
|
|
function getResolvedSymbol(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedSymbol) {
|
|
links.resolvedSymbol = !nodeIsMissing(node) && resolveName(
|
|
node,
|
|
node.escapedText,
|
|
111551 /* Value */ | 1048576 /* ExportValue */,
|
|
getCannotFindNameDiagnosticForName(node),
|
|
node,
|
|
!isWriteOnlyAccess(node),
|
|
false
|
|
) || unknownSymbol;
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function isInTypeQuery(node) {
|
|
return !!findAncestor(
|
|
node,
|
|
(n) => n.kind === 183 /* TypeQuery */ ? true : n.kind === 79 /* Identifier */ || n.kind === 163 /* QualifiedName */ ? false : "quit"
|
|
);
|
|
}
|
|
function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
if (!isThisInTypeQuery(node)) {
|
|
const symbol = getResolvedSymbol(node);
|
|
return symbol !== unknownSymbol ? `${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}|${getSymbolId(symbol)}` : void 0;
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
return `0|${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}`;
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
|
|
case 163 /* QualifiedName */:
|
|
const left = getFlowCacheKey(node.left, declaredType, initialType, flowContainer);
|
|
return left && left + "." + node.right.escapedText;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const propName = getAccessedPropertyName(node);
|
|
if (propName !== void 0) {
|
|
const key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
|
|
return key && key + "." + propName;
|
|
}
|
|
break;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
return `${getNodeId(node)}#${getTypeId(declaredType)}`;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isMatchingReference(source, target) {
|
|
switch (target.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return isMatchingReference(source, target.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isAssignmentExpression(target) && isMatchingReference(source, target.left) || isBinaryExpression(target) && target.operatorToken.kind === 27 /* CommaToken */ && isMatchingReference(source, target.right);
|
|
}
|
|
switch (source.kind) {
|
|
case 233 /* MetaProperty */:
|
|
return target.kind === 233 /* MetaProperty */ && source.keywordToken === target.keywordToken && source.name.escapedText === target.name.escapedText;
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return isThisInTypeQuery(source) ? target.kind === 108 /* ThisKeyword */ : target.kind === 79 /* Identifier */ && getResolvedSymbol(source) === getResolvedSymbol(target) || (target.kind === 257 /* VariableDeclaration */ || target.kind === 205 /* BindingElement */) && getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target);
|
|
case 108 /* ThisKeyword */:
|
|
return target.kind === 108 /* ThisKeyword */;
|
|
case 106 /* SuperKeyword */:
|
|
return target.kind === 106 /* SuperKeyword */;
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isMatchingReference(source.expression, target);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const sourcePropertyName = getAccessedPropertyName(source);
|
|
const targetPropertyName = isAccessExpression(target) ? getAccessedPropertyName(target) : void 0;
|
|
return sourcePropertyName !== void 0 && targetPropertyName !== void 0 && targetPropertyName === sourcePropertyName && isMatchingReference(source.expression, target.expression);
|
|
case 163 /* QualifiedName */:
|
|
return isAccessExpression(target) && source.right.escapedText === getAccessedPropertyName(target) && isMatchingReference(source.left, target.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isBinaryExpression(source) && source.operatorToken.kind === 27 /* CommaToken */ && isMatchingReference(source.right, target);
|
|
}
|
|
return false;
|
|
}
|
|
function getAccessedPropertyName(access) {
|
|
if (isPropertyAccessExpression(access)) {
|
|
return access.name.escapedText;
|
|
}
|
|
if (isElementAccessExpression(access)) {
|
|
return tryGetElementAccessExpressionName(access);
|
|
}
|
|
if (isBindingElement(access)) {
|
|
const name = getDestructuringPropertyName(access);
|
|
return name ? escapeLeadingUnderscores(name) : void 0;
|
|
}
|
|
if (isParameter(access)) {
|
|
return "" + access.parent.parameters.indexOf(access);
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetNameFromType(type) {
|
|
return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName : type.flags & 384 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
|
|
}
|
|
function tryGetElementAccessExpressionName(node) {
|
|
if (isStringOrNumericLiteralLike(node.argumentExpression)) {
|
|
return escapeLeadingUnderscores(node.argumentExpression.text);
|
|
}
|
|
if (isEntityNameExpression(node.argumentExpression)) {
|
|
const symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, true);
|
|
if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
|
|
return void 0;
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration === void 0)
|
|
return void 0;
|
|
const type = tryGetTypeFromEffectiveTypeNode(declaration);
|
|
if (type) {
|
|
const name = tryGetNameFromType(type);
|
|
if (name !== void 0) {
|
|
return name;
|
|
}
|
|
}
|
|
if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
|
|
const initializer = getEffectiveInitializer(declaration);
|
|
if (initializer) {
|
|
return tryGetNameFromType(getTypeOfExpression(initializer));
|
|
}
|
|
if (isEnumMember(declaration)) {
|
|
return getTextOfPropertyName(declaration.name);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function containsMatchingReference(source, target) {
|
|
while (isAccessExpression(source)) {
|
|
source = source.expression;
|
|
if (isMatchingReference(source, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function optionalChainContainsReference(source, target) {
|
|
while (isOptionalChain(source)) {
|
|
source = source.expression;
|
|
if (isMatchingReference(source, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isDiscriminantProperty(type, name) {
|
|
if (type && type.flags & 1048576 /* Union */) {
|
|
const prop = getUnionOrIntersectionProperty(type, name);
|
|
if (prop && getCheckFlags(prop) & 2 /* SyntheticProperty */) {
|
|
if (prop.isDiscriminantProperty === void 0) {
|
|
prop.isDiscriminantProperty = (prop.checkFlags & 192 /* Discriminant */) === 192 /* Discriminant */ && !isGenericType(getTypeOfSymbol(prop));
|
|
}
|
|
return !!prop.isDiscriminantProperty;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function findDiscriminantProperties(sourceProperties, target) {
|
|
let result;
|
|
for (const sourceProperty of sourceProperties) {
|
|
if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
|
|
if (result) {
|
|
result.push(sourceProperty);
|
|
continue;
|
|
}
|
|
result = [sourceProperty];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapTypesByKeyProperty(types, name) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
let count = 0;
|
|
for (const type of types) {
|
|
if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
const discriminant = getTypeOfPropertyOfType(type, name);
|
|
if (discriminant) {
|
|
if (!isLiteralType(discriminant)) {
|
|
return void 0;
|
|
}
|
|
let duplicate = false;
|
|
forEachType(discriminant, (t) => {
|
|
const id = getTypeId(getRegularTypeOfLiteralType(t));
|
|
const existing = map2.get(id);
|
|
if (!existing) {
|
|
map2.set(id, type);
|
|
} else if (existing !== unknownType) {
|
|
map2.set(id, unknownType);
|
|
duplicate = true;
|
|
}
|
|
});
|
|
if (!duplicate)
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count >= 10 && count * 2 >= types.length ? map2 : void 0;
|
|
}
|
|
function getKeyPropertyName(unionType) {
|
|
const types = unionType.types;
|
|
if (types.length < 10 || getObjectFlags(unionType) & 32768 /* PrimitiveUnion */ || countWhere(types, (t) => !!(t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */))) < 10) {
|
|
return void 0;
|
|
}
|
|
if (unionType.keyPropertyName === void 0) {
|
|
const keyPropertyName = forEach(types, (t) => t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) ? forEach(getPropertiesOfType(t), (p) => isUnitType(getTypeOfSymbol(p)) ? p.escapedName : void 0) : void 0);
|
|
const mapByKeyProperty = keyPropertyName && mapTypesByKeyProperty(types, keyPropertyName);
|
|
unionType.keyPropertyName = mapByKeyProperty ? keyPropertyName : "";
|
|
unionType.constituentMap = mapByKeyProperty;
|
|
}
|
|
return unionType.keyPropertyName.length ? unionType.keyPropertyName : void 0;
|
|
}
|
|
function getConstituentTypeForKeyType(unionType, keyType) {
|
|
var _a2;
|
|
const result = (_a2 = unionType.constituentMap) == null ? void 0 : _a2.get(getTypeId(getRegularTypeOfLiteralType(keyType)));
|
|
return result !== unknownType ? result : void 0;
|
|
}
|
|
function getMatchingUnionConstituentForType(unionType, type) {
|
|
const keyPropertyName = getKeyPropertyName(unionType);
|
|
const propType = keyPropertyName && getTypeOfPropertyOfType(type, keyPropertyName);
|
|
return propType && getConstituentTypeForKeyType(unionType, propType);
|
|
}
|
|
function getMatchingUnionConstituentForObjectLiteral(unionType, node) {
|
|
const keyPropertyName = getKeyPropertyName(unionType);
|
|
const propNode = keyPropertyName && find(node.properties, (p) => p.symbol && p.kind === 299 /* PropertyAssignment */ && p.symbol.escapedName === keyPropertyName && isPossiblyDiscriminantValue(p.initializer));
|
|
const 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 (const argument of expression.arguments) {
|
|
if (isOrContainsMatchingReference(reference, argument)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (expression.expression.kind === 208 /* 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 /* Union */)) {
|
|
return isTypeAssignableTo(source, target);
|
|
}
|
|
for (const t of source.types) {
|
|
if (isTypeAssignableTo(t, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getAssignmentReducedType(declaredType, assignedType) {
|
|
var _a2;
|
|
if (declaredType === assignedType) {
|
|
return declaredType;
|
|
}
|
|
if (assignedType.flags & 131072 /* Never */) {
|
|
return assignedType;
|
|
}
|
|
const key = `A${getTypeId(declaredType)},${getTypeId(assignedType)}`;
|
|
return (_a2 = getCachedType(key)) != null ? _a2 : setCachedType(key, getAssignmentReducedTypeWorker(declaredType, assignedType));
|
|
}
|
|
function getAssignmentReducedTypeWorker(declaredType, assignedType) {
|
|
const filteredType = filterType(declaredType, (t) => typeMaybeAssignableTo(assignedType, t));
|
|
const reducedType = assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
|
|
return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
|
|
}
|
|
function isFunctionObjectType(type) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
|
|
}
|
|
function getTypeFacts(type) {
|
|
if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
|
|
type = getBaseConstraintOfType(type) || unknownType;
|
|
}
|
|
const flags = type.flags;
|
|
if (flags & (4 /* String */ | 268435456 /* StringMapping */)) {
|
|
return strictNullChecks ? 16317953 /* StringStrictFacts */ : 16776705 /* StringFacts */;
|
|
}
|
|
if (flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
|
|
const isEmpty = flags & 128 /* StringLiteral */ && type.value === "";
|
|
return strictNullChecks ? isEmpty ? 12123649 /* EmptyStringStrictFacts */ : 7929345 /* NonEmptyStringStrictFacts */ : isEmpty ? 12582401 /* EmptyStringFacts */ : 16776705 /* NonEmptyStringFacts */;
|
|
}
|
|
if (flags & (8 /* Number */ | 32 /* Enum */)) {
|
|
return strictNullChecks ? 16317698 /* NumberStrictFacts */ : 16776450 /* NumberFacts */;
|
|
}
|
|
if (flags & 256 /* NumberLiteral */) {
|
|
const isZero = type.value === 0;
|
|
return strictNullChecks ? isZero ? 12123394 /* ZeroNumberStrictFacts */ : 7929090 /* NonZeroNumberStrictFacts */ : isZero ? 12582146 /* ZeroNumberFacts */ : 16776450 /* NonZeroNumberFacts */;
|
|
}
|
|
if (flags & 64 /* BigInt */) {
|
|
return strictNullChecks ? 16317188 /* BigIntStrictFacts */ : 16775940 /* BigIntFacts */;
|
|
}
|
|
if (flags & 2048 /* BigIntLiteral */) {
|
|
const isZero = isZeroBigInt(type);
|
|
return strictNullChecks ? isZero ? 12122884 /* ZeroBigIntStrictFacts */ : 7928580 /* NonZeroBigIntStrictFacts */ : isZero ? 12581636 /* ZeroBigIntFacts */ : 16775940 /* NonZeroBigIntFacts */;
|
|
}
|
|
if (flags & 16 /* Boolean */) {
|
|
return strictNullChecks ? 16316168 /* BooleanStrictFacts */ : 16774920 /* BooleanFacts */;
|
|
}
|
|
if (flags & 528 /* BooleanLike */) {
|
|
return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
|
|
}
|
|
if (flags & 524288 /* Object */) {
|
|
return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
|
|
}
|
|
if (flags & 16384 /* Void */) {
|
|
return 9830144 /* VoidFacts */;
|
|
}
|
|
if (flags & 32768 /* Undefined */) {
|
|
return 26607360 /* UndefinedFacts */;
|
|
}
|
|
if (flags & 65536 /* Null */) {
|
|
return 42917664 /* NullFacts */;
|
|
}
|
|
if (flags & 12288 /* ESSymbolLike */) {
|
|
return strictNullChecks ? 7925520 /* SymbolStrictFacts */ : 16772880 /* SymbolFacts */;
|
|
}
|
|
if (flags & 67108864 /* NonPrimitive */) {
|
|
return strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
|
|
}
|
|
if (flags & 131072 /* Never */) {
|
|
return 0 /* None */;
|
|
}
|
|
if (flags & 1048576 /* Union */) {
|
|
return reduceLeft(type.types, (facts, t) => facts | getTypeFacts(t), 0 /* None */);
|
|
}
|
|
if (flags & 2097152 /* Intersection */) {
|
|
return getIntersectionTypeFacts(type);
|
|
}
|
|
return 83886079 /* UnknownFacts */;
|
|
}
|
|
function getIntersectionTypeFacts(type) {
|
|
const ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */);
|
|
let oredFacts = 0 /* None */;
|
|
let andedFacts = 134217727 /* All */;
|
|
for (const t of type.types) {
|
|
if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
|
|
const f = getTypeFacts(t);
|
|
oredFacts |= f;
|
|
andedFacts &= f;
|
|
}
|
|
}
|
|
return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
|
|
}
|
|
function getTypeWithFacts(type, include) {
|
|
return filterType(type, (t) => (getTypeFacts(t) & include) !== 0);
|
|
}
|
|
function getAdjustedTypeWithFacts(type, facts) {
|
|
const reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
|
|
if (strictNullChecks) {
|
|
switch (facts) {
|
|
case 524288 /* NEUndefined */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
|
|
case 1048576 /* NENull */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
|
|
case 2097152 /* NEUndefinedOrNull */:
|
|
case 4194304 /* Truthy */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 262144 /* 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 _a2;
|
|
const nameType = getLiteralTypeFromPropertyName(name);
|
|
if (!isTypeUsableAsPropertyName(nameType))
|
|
return errorType;
|
|
const text = getPropertyNameFromType(nameType);
|
|
return getTypeOfPropertyOfType(type, text) || includeUndefinedInIndexSignature((_a2 = getApplicableIndexInfoForName(type, text)) == null ? void 0 : _a2.type) || errorType;
|
|
}
|
|
function getTypeOfDestructuredArrayElement(type, index) {
|
|
return everyType(type, isTupleLikeType) && getTupleElementType(type, index) || includeUndefinedInIndexSignature(checkIteratedTypeOrElementType(65 /* Destructuring */, type, undefinedType, void 0)) || errorType;
|
|
}
|
|
function includeUndefinedInIndexSignature(type) {
|
|
if (!type)
|
|
return type;
|
|
return compilerOptions.noUncheckedIndexedAccess ? getUnionType([type, undefinedType]) : type;
|
|
}
|
|
function getTypeOfDestructuredSpreadExpression(type) {
|
|
return createArrayType(checkIteratedTypeOrElementType(65 /* Destructuring */, type, undefinedType, void 0) || errorType);
|
|
}
|
|
function getAssignedTypeOfBinaryExpression(node) {
|
|
const isDestructuringDefaultAssignment = node.parent.kind === 206 /* ArrayLiteralExpression */ && isDestructuringAssignmentTarget(node.parent) || node.parent.kind === 299 /* PropertyAssignment */ && isDestructuringAssignmentTarget(node.parent.parent);
|
|
return isDestructuringDefaultAssignment ? getTypeWithDefault(getAssignedType(node), node.right) : getTypeOfExpression(node.right);
|
|
}
|
|
function isDestructuringAssignmentTarget(parent) {
|
|
return parent.parent.kind === 223 /* BinaryExpression */ && parent.parent.left === parent || parent.parent.kind === 247 /* 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) {
|
|
const { parent } = node;
|
|
switch (parent.kind) {
|
|
case 246 /* ForInStatement */:
|
|
return stringType;
|
|
case 247 /* ForOfStatement */:
|
|
return checkRightHandSideOfForOf(parent) || errorType;
|
|
case 223 /* BinaryExpression */:
|
|
return getAssignedTypeOfBinaryExpression(parent);
|
|
case 217 /* DeleteExpression */:
|
|
return undefinedType;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return getAssignedTypeOfArrayLiteralElement(parent, node);
|
|
case 227 /* SpreadElement */:
|
|
return getAssignedTypeOfSpreadExpression(parent);
|
|
case 299 /* PropertyAssignment */:
|
|
return getAssignedTypeOfPropertyAssignment(parent);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return getAssignedTypeOfShorthandPropertyAssignment(parent);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getInitialTypeOfBindingElement(node) {
|
|
const pattern = node.parent;
|
|
const parentType = getInitialType(pattern.parent);
|
|
const type = pattern.kind === 203 /* 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) {
|
|
const links = getNodeLinks(node);
|
|
return links.resolvedType || getTypeOfExpression(node);
|
|
}
|
|
function getInitialTypeOfVariableDeclaration(node) {
|
|
if (node.initializer) {
|
|
return getTypeOfInitializer(node.initializer);
|
|
}
|
|
if (node.parent.parent.kind === 246 /* ForInStatement */) {
|
|
return stringType;
|
|
}
|
|
if (node.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
return checkRightHandSideOfForOf(node.parent.parent) || errorType;
|
|
}
|
|
return errorType;
|
|
}
|
|
function getInitialType(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ ? getInitialTypeOfVariableDeclaration(node) : getInitialTypeOfBindingElement(node);
|
|
}
|
|
function isEmptyArrayAssignment(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ && node.initializer && isEmptyArrayLiteral2(node.initializer) || node.kind !== 205 /* BindingElement */ && node.parent.kind === 223 /* BinaryExpression */ && isEmptyArrayLiteral2(node.parent.right);
|
|
}
|
|
function getReferenceCandidate(node) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getReferenceCandidate(node.expression);
|
|
case 223 /* BinaryExpression */:
|
|
switch (node.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return getReferenceCandidate(node.left);
|
|
case 27 /* CommaToken */:
|
|
return getReferenceCandidate(node.right);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getReferenceRoot(node) {
|
|
const { parent } = node;
|
|
return parent.kind === 214 /* ParenthesizedExpression */ || parent.kind === 223 /* BinaryExpression */ && parent.operatorToken.kind === 63 /* EqualsToken */ && parent.left === node || parent.kind === 223 /* BinaryExpression */ && parent.operatorToken.kind === 27 /* CommaToken */ && parent.right === node ? getReferenceRoot(parent) : node;
|
|
}
|
|
function getTypeOfSwitchClause(clause) {
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression));
|
|
}
|
|
return neverType;
|
|
}
|
|
function getSwitchClauseTypes(switchStatement) {
|
|
const links = getNodeLinks(switchStatement);
|
|
if (!links.switchTypes) {
|
|
links.switchTypes = [];
|
|
for (const clause of switchStatement.caseBlock.clauses) {
|
|
links.switchTypes.push(getTypeOfSwitchClause(clause));
|
|
}
|
|
}
|
|
return links.switchTypes;
|
|
}
|
|
function getSwitchClauseTypeOfWitnesses(switchStatement) {
|
|
if (some(switchStatement.caseBlock.clauses, (clause) => clause.kind === 292 /* CaseClause */ && !isStringLiteralLike(clause.expression))) {
|
|
return void 0;
|
|
}
|
|
const witnesses = [];
|
|
for (const clause of switchStatement.caseBlock.clauses) {
|
|
const text = clause.kind === 292 /* CaseClause */ ? clause.expression.text : void 0;
|
|
witnesses.push(text && !contains(witnesses, text) ? text : void 0);
|
|
}
|
|
return witnesses;
|
|
}
|
|
function eachTypeContainedIn(source, types) {
|
|
return source.flags & 1048576 /* Union */ ? !forEach(source.types, (t) => !contains(types, t)) : contains(types, source);
|
|
}
|
|
function isTypeSubsetOf(source, target) {
|
|
return source === target || target.flags & 1048576 /* Union */ && isTypeSubsetOfUnion(source, target);
|
|
}
|
|
function isTypeSubsetOfUnion(source, target) {
|
|
if (source.flags & 1048576 /* Union */) {
|
|
for (const t of source.types) {
|
|
if (!containsType(target.types, t)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (source.flags & 1024 /* EnumLiteral */ && getBaseTypeOfEnumLiteralType(source) === target) {
|
|
return true;
|
|
}
|
|
return containsType(target.types, source);
|
|
}
|
|
function forEachType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? forEach(type.types, f) : f(type);
|
|
}
|
|
function someType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? some(type.types, f) : f(type);
|
|
}
|
|
function everyType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? every(type.types, f) : f(type);
|
|
}
|
|
function everyContainedType(type, f) {
|
|
return type.flags & 3145728 /* UnionOrIntersection */ ? every(type.types, f) : f(type);
|
|
}
|
|
function filterType(type, f) {
|
|
if (type.flags & 1048576 /* Union */) {
|
|
const types = type.types;
|
|
const filtered = filter(types, f);
|
|
if (filtered === types) {
|
|
return type;
|
|
}
|
|
const origin = type.origin;
|
|
let newOrigin;
|
|
if (origin && origin.flags & 1048576 /* Union */) {
|
|
const originTypes = origin.types;
|
|
const originFiltered = filter(originTypes, (t) => !!(t.flags & 1048576 /* Union */) || f(t));
|
|
if (originTypes.length - originFiltered.length === types.length - filtered.length) {
|
|
if (originFiltered.length === 1) {
|
|
return originFiltered[0];
|
|
}
|
|
newOrigin = createOriginUnionOrIntersectionType(1048576 /* Union */, originFiltered);
|
|
}
|
|
}
|
|
return getUnionTypeFromSortedList(filtered, type.objectFlags, void 0, void 0, newOrigin);
|
|
}
|
|
return type.flags & 131072 /* Never */ || f(type) ? type : neverType;
|
|
}
|
|
function removeType(type, targetType) {
|
|
return filterType(type, (t) => t !== targetType);
|
|
}
|
|
function countTypes(type) {
|
|
return type.flags & 1048576 /* Union */ ? type.types.length : 1;
|
|
}
|
|
function mapType(type, mapper, noReductions) {
|
|
if (type.flags & 131072 /* Never */) {
|
|
return type;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
return mapper(type);
|
|
}
|
|
const origin = type.origin;
|
|
const types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
|
|
let mappedTypes;
|
|
let changed = false;
|
|
for (const t of types) {
|
|
const mapped = t.flags & 1048576 /* 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 /* None */ : 1 /* Literal */) : type;
|
|
}
|
|
function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
|
|
}
|
|
function extractTypesOfKind(type, kind) {
|
|
return filterType(type, (t) => (t.flags & kind) !== 0);
|
|
}
|
|
function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
|
|
if (maybeTypeOfKind(typeWithPrimitives, 4 /* String */ | 134217728 /* TemplateLiteral */ | 8 /* Number */ | 64 /* BigInt */) && maybeTypeOfKind(typeWithLiterals, 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */)) {
|
|
return mapType(typeWithPrimitives, (t) => t.flags & 4 /* String */ ? extractTypesOfKind(typeWithLiterals, 4 /* String */ | 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) : isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 /* String */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? extractTypesOfKind(typeWithLiterals, 128 /* StringLiteral */) : t.flags & 8 /* Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* Number */ | 256 /* NumberLiteral */) : t.flags & 64 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* BigInt */ | 2048 /* 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 /* Never */ ? silentNeverType : type } : type;
|
|
}
|
|
function createEvolvingArrayType(elementType) {
|
|
const result = createObjectType(256 /* EvolvingArray */);
|
|
result.elementType = elementType;
|
|
return result;
|
|
}
|
|
function getEvolvingArrayType(elementType) {
|
|
return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType));
|
|
}
|
|
function addEvolvingArrayElementType(evolvingArrayType, node) {
|
|
const elementType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node)));
|
|
return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType]));
|
|
}
|
|
function createFinalArrayType(elementType) {
|
|
return elementType.flags & 131072 /* Never */ ? autoArrayType : createArrayType(elementType.flags & 1048576 /* Union */ ? getUnionType(elementType.types, 2 /* Subtype */) : elementType);
|
|
}
|
|
function getFinalArrayType(evolvingArrayType) {
|
|
return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType));
|
|
}
|
|
function finalizeEvolvingArrayType(type) {
|
|
return getObjectFlags(type) & 256 /* EvolvingArray */ ? getFinalArrayType(type) : type;
|
|
}
|
|
function getElementTypeOfEvolvingArrayType(type) {
|
|
return getObjectFlags(type) & 256 /* EvolvingArray */ ? type.elementType : neverType;
|
|
}
|
|
function isEvolvingArrayTypeList(types) {
|
|
let hasEvolvingArrayType = false;
|
|
for (const t of types) {
|
|
if (!(t.flags & 131072 /* Never */)) {
|
|
if (!(getObjectFlags(t) & 256 /* EvolvingArray */)) {
|
|
return false;
|
|
}
|
|
hasEvolvingArrayType = true;
|
|
}
|
|
}
|
|
return hasEvolvingArrayType;
|
|
}
|
|
function isEvolvingArrayOperationTarget(node) {
|
|
const root = getReferenceRoot(node);
|
|
const parent = root.parent;
|
|
const isLengthPushOrUnshift = isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" || parent.parent.kind === 210 /* CallExpression */ && isIdentifier(parent.name) && isPushOrUnshiftIdentifier(parent.name));
|
|
const isElementAssignment = parent.kind === 209 /* ElementAccessExpression */ && parent.expression === root && parent.parent.kind === 223 /* BinaryExpression */ && parent.parent.operatorToken.kind === 63 /* EqualsToken */ && parent.parent.left === parent && !isAssignmentTarget(parent.parent) && isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296 /* NumberLike */);
|
|
return isLengthPushOrUnshift || isElementAssignment;
|
|
}
|
|
function isDeclarationWithExplicitTypeAnnotation(node) {
|
|
return (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isParameter(node)) && !!(getEffectiveTypeAnnotationNode(node) || isInJSFile(node) && hasInitializer(node) && node.initializer && isFunctionExpressionOrArrowFunction(node.initializer) && getEffectiveReturnTypeNode(node.initializer));
|
|
}
|
|
function getExplicitTypeOfSymbol(symbol, diagnostic) {
|
|
symbol = resolveSymbol(symbol);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 512 /* ValueModule */)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
|
|
if (getCheckFlags(symbol) & 262144 /* Mapped */) {
|
|
const origin = symbol.syntheticOrigin;
|
|
if (origin && getExplicitTypeOfSymbol(origin)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration) {
|
|
if (isDeclarationWithExplicitTypeAnnotation(declaration)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
const statement = declaration.parent.parent;
|
|
const expressionType = getTypeOfDottedName(statement.expression, void 0);
|
|
if (expressionType) {
|
|
const use = statement.awaitModifier ? 15 /* ForAwaitOf */ : 13 /* ForOf */;
|
|
return checkIteratedTypeOrElementType(use, expressionType, undefinedType, void 0);
|
|
}
|
|
}
|
|
if (diagnostic) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(declaration, Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfDottedName(node, diagnostic) {
|
|
if (!(node.flags & 33554432 /* InWithStatement */)) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
const symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
|
|
return getExplicitTypeOfSymbol(symbol, diagnostic);
|
|
case 108 /* ThisKeyword */:
|
|
return getExplicitThisType(node);
|
|
case 106 /* SuperKeyword */:
|
|
return checkSuperExpression(node);
|
|
case 208 /* PropertyAccessExpression */: {
|
|
const type = getTypeOfDottedName(node.expression, diagnostic);
|
|
if (type) {
|
|
const name = node.name;
|
|
let prop;
|
|
if (isPrivateIdentifier(name)) {
|
|
if (!type.symbol) {
|
|
return void 0;
|
|
}
|
|
prop = getPropertyOfType(type, getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText));
|
|
} else {
|
|
prop = getPropertyOfType(type, name.escapedText);
|
|
}
|
|
return prop && getExplicitTypeOfSymbol(prop, diagnostic);
|
|
}
|
|
return void 0;
|
|
}
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getTypeOfDottedName(node.expression, diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function getEffectsSignature(node) {
|
|
const links = getNodeLinks(node);
|
|
let signature = links.effectsSignature;
|
|
if (signature === void 0) {
|
|
let funcType;
|
|
if (node.parent.kind === 241 /* ExpressionStatement */) {
|
|
funcType = getTypeOfDottedName(node.expression, void 0);
|
|
} else if (node.expression.kind !== 106 /* SuperKeyword */) {
|
|
if (isOptionalChain(node)) {
|
|
funcType = checkNonNullType(
|
|
getOptionalExpressionType(checkExpression(node.expression), node.expression),
|
|
node.expression
|
|
);
|
|
} else {
|
|
funcType = checkNonNullExpression(node.expression);
|
|
}
|
|
}
|
|
const signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0 /* Call */);
|
|
const candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] : some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) : void 0;
|
|
signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature;
|
|
}
|
|
return signature === unknownSignature ? void 0 : signature;
|
|
}
|
|
function hasTypePredicateOrNeverReturnType(signature) {
|
|
return !!(getTypePredicateOfSignature(signature) || signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072 /* Never */);
|
|
}
|
|
function getTypePredicateArgument(predicate, callExpression) {
|
|
if (predicate.kind === 1 /* Identifier */ || predicate.kind === 3 /* AssertsIdentifier */) {
|
|
return callExpression.arguments[predicate.parameterIndex];
|
|
}
|
|
const invokedExpression = skipParentheses(callExpression.expression);
|
|
return isAccessExpression(invokedExpression) ? skipParentheses(invokedExpression.expression) : void 0;
|
|
}
|
|
function reportFlowControlError(node) {
|
|
const block = findAncestor(node, isFunctionOrModuleBlock);
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const span = getSpanOfTokenAtPosition(sourceFile, block.statements.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis));
|
|
}
|
|
function isReachableFlowNode(flow) {
|
|
const result = isReachableFlowNodeWorker(flow, false);
|
|
lastFlowNode = flow;
|
|
lastFlowNodeReachable = result;
|
|
return result;
|
|
}
|
|
function isFalseExpression(expr) {
|
|
const node = skipParentheses(expr, true);
|
|
return node.kind === 95 /* FalseKeyword */ || node.kind === 223 /* BinaryExpression */ && (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ && (isFalseExpression(node.left) || isFalseExpression(node.right)) || node.operatorToken.kind === 56 /* BarBarToken */ && isFalseExpression(node.left) && isFalseExpression(node.right));
|
|
}
|
|
function isReachableFlowNodeWorker(flow, noCacheCheck) {
|
|
while (true) {
|
|
if (flow === lastFlowNode) {
|
|
return lastFlowNodeReachable;
|
|
}
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
if (!noCacheCheck) {
|
|
const id = getFlowNodeId(flow);
|
|
const reachable = flowNodeReachable[id];
|
|
return reachable !== void 0 ? reachable : flowNodeReachable[id] = isReachableFlowNodeWorker(flow, true);
|
|
}
|
|
noCacheCheck = false;
|
|
}
|
|
if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */)) {
|
|
flow = flow.antecedent;
|
|
} else if (flags & 512 /* Call */) {
|
|
const signature = getEffectsSignature(flow.node);
|
|
if (signature) {
|
|
const predicate = getTypePredicateOfSignature(signature);
|
|
if (predicate && predicate.kind === 3 /* AssertsIdentifier */ && !predicate.type) {
|
|
const predicateArgument = flow.node.arguments[predicate.parameterIndex];
|
|
if (predicateArgument && isFalseExpression(predicateArgument)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (getReturnTypeOfSignature(signature).flags & 131072 /* Never */) {
|
|
return false;
|
|
}
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 4 /* BranchLabel */) {
|
|
return some(flow.antecedents, (f) => isReachableFlowNodeWorker(f, false));
|
|
} else if (flags & 8 /* LoopLabel */) {
|
|
const antecedents = flow.antecedents;
|
|
if (antecedents === void 0 || antecedents.length === 0) {
|
|
return false;
|
|
}
|
|
flow = antecedents[0];
|
|
} else if (flags & 128 /* SwitchClause */) {
|
|
if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
|
|
return false;
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
lastFlowNode = void 0;
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
const result = isReachableFlowNodeWorker(flow.antecedent, false);
|
|
target.antecedents = saveAntecedents;
|
|
return result;
|
|
} else {
|
|
return !(flags & 1 /* Unreachable */);
|
|
}
|
|
}
|
|
}
|
|
function isPostSuperFlowNode(flow, noCacheCheck) {
|
|
while (true) {
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
if (!noCacheCheck) {
|
|
const id = getFlowNodeId(flow);
|
|
const postSuper = flowNodePostSuper[id];
|
|
return postSuper !== void 0 ? postSuper : flowNodePostSuper[id] = isPostSuperFlowNode(flow, true);
|
|
}
|
|
noCacheCheck = false;
|
|
}
|
|
if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */ | 128 /* SwitchClause */)) {
|
|
flow = flow.antecedent;
|
|
} else if (flags & 512 /* Call */) {
|
|
if (flow.node.expression.kind === 106 /* SuperKeyword */) {
|
|
return true;
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 4 /* BranchLabel */) {
|
|
return every(flow.antecedents, (f) => isPostSuperFlowNode(f, false));
|
|
} else if (flags & 8 /* LoopLabel */) {
|
|
flow = flow.antecedents[0];
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
const result = isPostSuperFlowNode(flow.antecedent, false);
|
|
target.antecedents = saveAntecedents;
|
|
return result;
|
|
} else {
|
|
return !!(flags & 1 /* Unreachable */);
|
|
}
|
|
}
|
|
}
|
|
function isConstantReference(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */: {
|
|
const symbol = getResolvedSymbol(node);
|
|
return isConstVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return isConstantReference(node.expression) && isReadonlySymbol(getNodeLinks(node).resolvedSymbol || unknownSymbol);
|
|
}
|
|
return false;
|
|
}
|
|
function getFlowTypeOfReference(reference, declaredType, initialType = declaredType, flowContainer, flowNode = reference.flowNode) {
|
|
let key;
|
|
let isKeySet = false;
|
|
let flowDepth = 0;
|
|
if (flowAnalysisDisabled) {
|
|
return errorType;
|
|
}
|
|
if (!flowNode) {
|
|
return declaredType;
|
|
}
|
|
flowInvocationCount++;
|
|
const sharedFlowStart = sharedFlowCount;
|
|
const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
|
|
sharedFlowCount = sharedFlowStart;
|
|
const resultType = getObjectFlags(evolvedType) & 256 /* EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
|
|
if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 232 /* NonNullExpression */ && !(resultType.flags & 131072 /* Never */) && getTypeWithFacts(resultType, 2097152 /* NEUndefinedOrNull */).flags & 131072 /* Never */) {
|
|
return declaredType;
|
|
}
|
|
return resultType === nonNullUnknownType ? unknownType : resultType;
|
|
function getOrSetCacheKey() {
|
|
if (isKeySet) {
|
|
return key;
|
|
}
|
|
isKeySet = true;
|
|
return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer);
|
|
}
|
|
function getTypeAtFlowNode(flow) {
|
|
var _a2;
|
|
if (flowDepth === 2e3) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id });
|
|
flowAnalysisDisabled = true;
|
|
reportFlowControlError(reference);
|
|
return errorType;
|
|
}
|
|
flowDepth++;
|
|
let sharedFlow;
|
|
while (true) {
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
for (let i = sharedFlowStart; i < sharedFlowCount; i++) {
|
|
if (sharedFlowNodes[i] === flow) {
|
|
flowDepth--;
|
|
return sharedFlowTypes[i];
|
|
}
|
|
}
|
|
sharedFlow = flow;
|
|
}
|
|
let type;
|
|
if (flags & 16 /* Assignment */) {
|
|
type = getTypeAtFlowAssignment(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 512 /* Call */) {
|
|
type = getTypeAtFlowCall(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 96 /* Condition */) {
|
|
type = getTypeAtFlowCondition(flow);
|
|
} else if (flags & 128 /* SwitchClause */) {
|
|
type = getTypeAtSwitchClause(flow);
|
|
} else if (flags & 12 /* Label */) {
|
|
if (flow.antecedents.length === 1) {
|
|
flow = flow.antecedents[0];
|
|
continue;
|
|
}
|
|
type = flags & 4 /* BranchLabel */ ? getTypeAtFlowBranchLabel(flow) : getTypeAtFlowLoopLabel(flow);
|
|
} else if (flags & 256 /* ArrayMutation */) {
|
|
type = getTypeAtFlowArrayMutation(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
type = getTypeAtFlowNode(flow.antecedent);
|
|
target.antecedents = saveAntecedents;
|
|
} else if (flags & 2 /* Start */) {
|
|
const container = flow.node;
|
|
if (container && container !== flowContainer && reference.kind !== 208 /* PropertyAccessExpression */ && reference.kind !== 209 /* ElementAccessExpression */ && reference.kind !== 108 /* ThisKeyword */) {
|
|
flow = container.flowNode;
|
|
continue;
|
|
}
|
|
type = initialType;
|
|
} else {
|
|
type = convertAutoToAny(declaredType);
|
|
}
|
|
if (sharedFlow) {
|
|
sharedFlowNodes[sharedFlowCount] = sharedFlow;
|
|
sharedFlowTypes[sharedFlowCount] = type;
|
|
sharedFlowCount++;
|
|
}
|
|
flowDepth--;
|
|
return type;
|
|
}
|
|
}
|
|
function getInitialOrAssignedType(flow) {
|
|
const node = flow.node;
|
|
return getNarrowableTypeForReference(node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */ ? getInitialType(node) : getAssignedType(node), reference);
|
|
}
|
|
function getTypeAtFlowAssignment(flow) {
|
|
const node = flow.node;
|
|
if (isMatchingReference(reference, node)) {
|
|
if (!isReachableFlowNode(flow)) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (getAssignmentTargetKind(node) === 2 /* Compound */) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
|
|
}
|
|
if (declaredType === autoType || declaredType === autoArrayType) {
|
|
if (isEmptyArrayAssignment(node)) {
|
|
return getEvolvingArrayType(neverType);
|
|
}
|
|
const assignedType = getWidenedLiteralType(getInitialOrAssignedType(flow));
|
|
return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType;
|
|
}
|
|
if (declaredType.flags & 1048576 /* Union */) {
|
|
return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow));
|
|
}
|
|
return declaredType;
|
|
}
|
|
if (containsMatchingReference(reference, node)) {
|
|
if (!isReachableFlowNode(flow)) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (isVariableDeclaration(node) && (isInJSFile(node) || isVarConst(node))) {
|
|
const init = getDeclaredExpandoInitializer(node);
|
|
if (init && (init.kind === 215 /* FunctionExpression */ || init.kind === 216 /* ArrowFunction */)) {
|
|
return getTypeAtFlowNode(flow.antecedent);
|
|
}
|
|
}
|
|
return declaredType;
|
|
}
|
|
if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && isMatchingReference(reference, node.parent.parent.expression)) {
|
|
return getNonNullableTypeIfNeeded(finalizeEvolvingArrayType(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent))));
|
|
}
|
|
return void 0;
|
|
}
|
|
function narrowTypeByAssertion(type, expr) {
|
|
const node = skipParentheses(expr, true);
|
|
if (node.kind === 95 /* FalseKeyword */) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (node.kind === 223 /* BinaryExpression */) {
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right);
|
|
}
|
|
if (node.operatorToken.kind === 56 /* BarBarToken */) {
|
|
return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]);
|
|
}
|
|
}
|
|
return narrowType(type, node, true);
|
|
}
|
|
function getTypeAtFlowCall(flow) {
|
|
const signature = getEffectsSignature(flow.node);
|
|
if (signature) {
|
|
const predicate = getTypePredicateOfSignature(signature);
|
|
if (predicate && (predicate.kind === 2 /* AssertsThis */ || predicate.kind === 3 /* AssertsIdentifier */)) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = finalizeEvolvingArrayType(getTypeFromFlowType(flowType));
|
|
const narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, true) : predicate.kind === 3 /* 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 /* Never */) {
|
|
return unreachableNeverType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeAtFlowArrayMutation(flow) {
|
|
if (declaredType === autoType || declaredType === autoArrayType) {
|
|
const node = flow.node;
|
|
const expr = node.kind === 210 /* CallExpression */ ? node.expression.expression : node.left.expression;
|
|
if (isMatchingReference(reference, getReferenceCandidate(expr))) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (getObjectFlags(type) & 256 /* EvolvingArray */) {
|
|
let evolvedType2 = type;
|
|
if (node.kind === 210 /* CallExpression */) {
|
|
for (const arg of node.arguments) {
|
|
evolvedType2 = addEvolvingArrayElementType(evolvedType2, arg);
|
|
}
|
|
} else {
|
|
const indexType = getContextFreeTypeOfExpression(node.left.argumentExpression);
|
|
if (isTypeAssignableToKind(indexType, 296 /* NumberLike */)) {
|
|
evolvedType2 = addEvolvingArrayElementType(evolvedType2, node.right);
|
|
}
|
|
}
|
|
return evolvedType2 === type ? flowType : createFlowType(evolvedType2, isIncomplete(flowType));
|
|
}
|
|
return flowType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeAtFlowCondition(flow) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (type.flags & 131072 /* Never */) {
|
|
return flowType;
|
|
}
|
|
const assumeTrue = (flow.flags & 32 /* TrueCondition */) !== 0;
|
|
const nonEvolvingType = finalizeEvolvingArrayType(type);
|
|
const narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue);
|
|
if (narrowedType === nonEvolvingType) {
|
|
return flowType;
|
|
}
|
|
return createFlowType(narrowedType, isIncomplete(flowType));
|
|
}
|
|
function getTypeAtSwitchClause(flow) {
|
|
const expr = flow.switchStatement.expression;
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
let type = getTypeFromFlowType(flowType);
|
|
if (isMatchingReference(reference, expr)) {
|
|
type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
|
|
} else if (expr.kind === 218 /* 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,
|
|
(t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */))
|
|
);
|
|
} else if (expr.kind === 218 /* TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) {
|
|
type = narrowTypeBySwitchOptionalChainContainment(
|
|
type,
|
|
flow.switchStatement,
|
|
flow.clauseStart,
|
|
flow.clauseEnd,
|
|
(t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined")
|
|
);
|
|
}
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
|
|
}
|
|
}
|
|
return createFlowType(type, isIncomplete(flowType));
|
|
}
|
|
function getTypeAtFlowBranchLabel(flow) {
|
|
const antecedentTypes = [];
|
|
let subtypeReduction = false;
|
|
let seenIncomplete = false;
|
|
let bypassFlow;
|
|
for (const antecedent of flow.antecedents) {
|
|
if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.clauseStart === antecedent.clauseEnd) {
|
|
bypassFlow = antecedent;
|
|
continue;
|
|
}
|
|
const flowType = getTypeAtFlowNode(antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (type === declaredType && declaredType === initialType) {
|
|
return type;
|
|
}
|
|
pushIfUnique(antecedentTypes, type);
|
|
if (!isTypeSubsetOf(type, declaredType)) {
|
|
subtypeReduction = true;
|
|
}
|
|
if (isIncomplete(flowType)) {
|
|
seenIncomplete = true;
|
|
}
|
|
}
|
|
if (bypassFlow) {
|
|
const flowType = getTypeAtFlowNode(bypassFlow);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (!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 /* Subtype */ : 1 /* Literal */), seenIncomplete);
|
|
}
|
|
function getTypeAtFlowLoopLabel(flow) {
|
|
const id = getFlowNodeId(flow);
|
|
const cache = flowLoopCaches[id] || (flowLoopCaches[id] = /* @__PURE__ */ new Map());
|
|
const key2 = getOrSetCacheKey();
|
|
if (!key2) {
|
|
return declaredType;
|
|
}
|
|
const cached = cache.get(key2);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
for (let i = flowLoopStart; i < flowLoopCount; i++) {
|
|
if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key2 && flowLoopTypes[i].length) {
|
|
return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1 /* Literal */), true);
|
|
}
|
|
}
|
|
const antecedentTypes = [];
|
|
let subtypeReduction = false;
|
|
let firstAntecedentType;
|
|
for (const antecedent of flow.antecedents) {
|
|
let flowType;
|
|
if (!firstAntecedentType) {
|
|
flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
|
|
} else {
|
|
flowLoopNodes[flowLoopCount] = flow;
|
|
flowLoopKeys[flowLoopCount] = key2;
|
|
flowLoopTypes[flowLoopCount] = antecedentTypes;
|
|
flowLoopCount++;
|
|
const saveFlowTypeCache = flowTypeCache;
|
|
flowTypeCache = void 0;
|
|
flowType = getTypeAtFlowNode(antecedent);
|
|
flowTypeCache = saveFlowTypeCache;
|
|
flowLoopCount--;
|
|
const cached2 = cache.get(key2);
|
|
if (cached2) {
|
|
return cached2;
|
|
}
|
|
}
|
|
const type = getTypeFromFlowType(flowType);
|
|
pushIfUnique(antecedentTypes, type);
|
|
if (!isTypeSubsetOf(type, declaredType)) {
|
|
subtypeReduction = true;
|
|
}
|
|
if (type === declaredType) {
|
|
break;
|
|
}
|
|
}
|
|
const result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 /* Subtype */ : 1 /* Literal */);
|
|
if (isIncomplete(firstAntecedentType)) {
|
|
return createFlowType(result, true);
|
|
}
|
|
cache.set(key2, result);
|
|
return result;
|
|
}
|
|
function getUnionOrEvolvingArrayType(types, subtypeReduction) {
|
|
if (isEvolvingArrayTypeList(types)) {
|
|
return getEvolvingArrayType(getUnionType(map(types, getElementTypeOfEvolvingArrayType)));
|
|
}
|
|
const result = recombineUnknownType(getUnionType(sameMap(types, finalizeEvolvingArrayType), subtypeReduction));
|
|
if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && arraysEqual(result.types, declaredType.types)) {
|
|
return declaredType;
|
|
}
|
|
return result;
|
|
}
|
|
function getCandidateDiscriminantPropertyAccess(expr) {
|
|
if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
|
|
if (isIdentifier(expr)) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
|
|
return declaration;
|
|
}
|
|
}
|
|
} else if (isAccessExpression(expr)) {
|
|
if (isMatchingReference(reference, expr.expression)) {
|
|
return expr;
|
|
}
|
|
} else if (isIdentifier(expr)) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
|
|
return declaration.initializer;
|
|
}
|
|
if (isBindingElement(declaration) && !declaration.initializer) {
|
|
const parent = declaration.parent.parent;
|
|
if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) && isMatchingReference(reference, parent.initializer)) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDiscriminantPropertyAccess(expr, computedType) {
|
|
const type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
|
|
if (type.flags & 1048576 /* Union */) {
|
|
const access = getCandidateDiscriminantPropertyAccess(expr);
|
|
if (access) {
|
|
const name = getAccessedPropertyName(access);
|
|
if (name && isDiscriminantProperty(type, name)) {
|
|
return access;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function narrowTypeByDiscriminant(type, access, narrowType2) {
|
|
const propName = getAccessedPropertyName(access);
|
|
if (propName === void 0) {
|
|
return type;
|
|
}
|
|
const removeNullable = strictNullChecks && isOptionalChain(access) && maybeTypeOfKind(type, 98304 /* Nullable */);
|
|
let propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type, propName);
|
|
if (!propType) {
|
|
return type;
|
|
}
|
|
propType = removeNullable ? getOptionalType(propType) : propType;
|
|
const narrowedPropType = narrowType2(propType);
|
|
return filterType(type, (t) => {
|
|
const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
|
|
return !(discriminantType.flags & 131072 /* Never */) && !(narrowedPropType.flags & 131072 /* Never */) && areTypesComparable(narrowedPropType, discriminantType);
|
|
});
|
|
}
|
|
function narrowTypeByDiscriminantProperty(type, access, operator, value, assumeTrue) {
|
|
if ((operator === 36 /* EqualsEqualsEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) && type.flags & 1048576 /* Union */) {
|
|
const keyPropertyName = getKeyPropertyName(type);
|
|
if (keyPropertyName && keyPropertyName === getAccessedPropertyName(access)) {
|
|
const candidate = getConstituentTypeForKeyType(type, getTypeOfExpression(value));
|
|
if (candidate) {
|
|
return operator === (assumeTrue ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */) ? candidate : isUnitType(getTypeOfPropertyOfType(candidate, keyPropertyName) || unknownType) ? removeType(type, candidate) : type;
|
|
}
|
|
}
|
|
}
|
|
return narrowTypeByDiscriminant(type, access, (t) => narrowTypeByEquality(t, operator, value, assumeTrue));
|
|
}
|
|
function narrowTypeBySwitchOnDiscriminantProperty(type, access, switchStatement, clauseStart, clauseEnd) {
|
|
if (clauseStart < clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
|
|
const clauseTypes = getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd);
|
|
const candidate = getUnionType(map(clauseTypes, (t) => getConstituentTypeForKeyType(type, t) || unknownType));
|
|
if (candidate !== unknownType) {
|
|
return candidate;
|
|
}
|
|
}
|
|
return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, switchStatement, clauseStart, clauseEnd));
|
|
}
|
|
function narrowTypeByTruthiness(type, expr, assumeTrue) {
|
|
if (isMatchingReference(reference, expr)) {
|
|
return getAdjustedTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
|
|
}
|
|
if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
|
|
type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getTypeWithFacts(t, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */));
|
|
}
|
|
return type;
|
|
}
|
|
function isTypePresencePossible(type, propName, assumeTrue) {
|
|
const prop = getPropertyOfType(type, propName);
|
|
return prop ? !!(prop.flags & 16777216 /* Optional */) || assumeTrue : !!getApplicableIndexInfoForName(type, propName) || !assumeTrue;
|
|
}
|
|
function narrowTypeByInKeyword(type, nameType, assumeTrue) {
|
|
const name = getPropertyNameFromType(nameType);
|
|
const isKnownProperty2 = someType(type, (t) => isTypePresencePossible(t, name, true));
|
|
if (isKnownProperty2) {
|
|
return filterType(type, (t) => isTypePresencePossible(t, name, assumeTrue));
|
|
}
|
|
if (assumeTrue) {
|
|
const recordSymbol = getGlobalRecordSymbol();
|
|
if (recordSymbol) {
|
|
return getIntersectionType([type, getTypeAliasInstantiation(recordSymbol, [nameType, unknownType])]);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue);
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
const operator = expr.operatorToken.kind;
|
|
const left = getReferenceCandidate(expr.left);
|
|
const right = getReferenceCandidate(expr.right);
|
|
if (left.kind === 218 /* TypeOfExpression */ && isStringLiteralLike(right)) {
|
|
return narrowTypeByTypeof(type, left, operator, right, assumeTrue);
|
|
}
|
|
if (right.kind === 218 /* TypeOfExpression */ && 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);
|
|
}
|
|
}
|
|
const leftAccess = getDiscriminantPropertyAccess(left, type);
|
|
if (leftAccess) {
|
|
return narrowTypeByDiscriminantProperty(type, leftAccess, operator, right, assumeTrue);
|
|
}
|
|
const 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 /* InstanceOfKeyword */:
|
|
return narrowTypeByInstanceof(type, expr, assumeTrue);
|
|
case 101 /* InKeyword */:
|
|
if (isPrivateIdentifier(expr.left)) {
|
|
return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
|
|
}
|
|
const target = getReferenceCandidate(expr.right);
|
|
const leftType = getTypeOfExpression(expr.left);
|
|
if (leftType.flags & 8576 /* StringOrNumberLiteralOrUnique */) {
|
|
if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
|
|
return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
|
|
}
|
|
if (isMatchingReference(reference, target)) {
|
|
return narrowTypeByInKeyword(type, leftType, assumeTrue);
|
|
}
|
|
}
|
|
break;
|
|
case 27 /* CommaToken */:
|
|
return narrowType(type, expr.right, assumeTrue);
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
return assumeTrue ? narrowType(narrowType(type, expr.left, true), expr.right, true) : getUnionType([narrowType(type, expr.left, false), narrowType(type, expr.right, false)]);
|
|
case 56 /* BarBarToken */:
|
|
return assumeTrue ? getUnionType([narrowType(type, expr.left, true), narrowType(type, expr.right, true)]) : narrowType(narrowType(type, expr.left, false), expr.right, false);
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue) {
|
|
const target = getReferenceCandidate(expr.right);
|
|
if (!isMatchingReference(reference, target)) {
|
|
return type;
|
|
}
|
|
Debug.assertNode(expr.left, isPrivateIdentifier);
|
|
const symbol = getSymbolForPrivateIdentifierExpression(expr.left);
|
|
if (symbol === void 0) {
|
|
return type;
|
|
}
|
|
const classSymbol = symbol.parent;
|
|
const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
|
|
return getNarrowedType(type, targetType, assumeTrue, true);
|
|
}
|
|
function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
|
|
const equalsOperator = operator === 34 /* EqualsEqualsToken */ || operator === 36 /* EqualsEqualsEqualsToken */;
|
|
const nullableFlags = operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */ ? 98304 /* Nullable */ : 32768 /* Undefined */;
|
|
const valueType = getTypeOfExpression(value);
|
|
const removeNullable = equalsOperator !== assumeTrue && everyType(valueType, (t) => !!(t.flags & nullableFlags)) || equalsOperator === assumeTrue && everyType(valueType, (t) => !(t.flags & (3 /* AnyOrUnknown */ | nullableFlags)));
|
|
return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
|
|
}
|
|
function narrowTypeByEquality(type, operator, value, assumeTrue) {
|
|
if (type.flags & 1 /* Any */) {
|
|
return type;
|
|
}
|
|
if (operator === 35 /* ExclamationEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) {
|
|
assumeTrue = !assumeTrue;
|
|
}
|
|
const valueType = getTypeOfExpression(value);
|
|
const doubleEquals = operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */;
|
|
if (valueType.flags & 98304 /* Nullable */) {
|
|
if (!strictNullChecks) {
|
|
return type;
|
|
}
|
|
const facts = doubleEquals ? assumeTrue ? 262144 /* EQUndefinedOrNull */ : 2097152 /* NEUndefinedOrNull */ : valueType.flags & 65536 /* Null */ ? assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ : assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
|
|
return getAdjustedTypeWithFacts(type, facts);
|
|
}
|
|
if (assumeTrue) {
|
|
if (!doubleEquals && (type.flags & 2 /* Unknown */ || someType(type, isEmptyAnonymousObjectType))) {
|
|
if (valueType.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */) || isEmptyAnonymousObjectType(valueType)) {
|
|
return valueType;
|
|
}
|
|
if (valueType.flags & 524288 /* Object */) {
|
|
return nonPrimitiveType;
|
|
}
|
|
}
|
|
const filteredType = filterType(type, (t) => areTypesComparable(t, valueType) || doubleEquals && isCoercibleUnderDoubleEquals(t, valueType));
|
|
return replacePrimitivesWithLiterals(filteredType, valueType);
|
|
}
|
|
if (isUnitType(valueType)) {
|
|
return filterType(type, (t) => !(isUnitLikeType(t) && areTypesComparable(t, valueType)));
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
|
|
if (operator === 35 /* ExclamationEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) {
|
|
assumeTrue = !assumeTrue;
|
|
}
|
|
const target = getReferenceCandidate(typeOfExpr.expression);
|
|
if (!isMatchingReference(reference, target)) {
|
|
const propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type);
|
|
if (propertyAccess) {
|
|
return narrowTypeByDiscriminant(type, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal, assumeTrue));
|
|
}
|
|
if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
|
|
return getAdjustedTypeWithFacts(type, 2097152 /* 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 /* TypeofNEHostObject */);
|
|
}
|
|
function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
|
|
const everyClauseChecks = clauseStart !== clauseEnd && every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
|
|
return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
|
|
}
|
|
function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
|
|
const switchTypes = getSwitchClauseTypes(switchStatement);
|
|
if (!switchTypes.length) {
|
|
return type;
|
|
}
|
|
const clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
|
|
const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType);
|
|
if (type.flags & 2 /* Unknown */ && !hasDefaultClause) {
|
|
let groundClauseTypes;
|
|
for (let i = 0; i < clauseTypes.length; i += 1) {
|
|
const t = clauseTypes[i];
|
|
if (t.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */)) {
|
|
if (groundClauseTypes !== void 0) {
|
|
groundClauseTypes.push(t);
|
|
}
|
|
} else if (t.flags & 524288 /* Object */) {
|
|
if (groundClauseTypes === void 0) {
|
|
groundClauseTypes = clauseTypes.slice(0, i);
|
|
}
|
|
groundClauseTypes.push(nonPrimitiveType);
|
|
} else {
|
|
return type;
|
|
}
|
|
}
|
|
return getUnionType(groundClauseTypes === void 0 ? clauseTypes : groundClauseTypes);
|
|
}
|
|
const discriminantType = getUnionType(clauseTypes);
|
|
const caseType = discriminantType.flags & 131072 /* Never */ ? neverType : replacePrimitivesWithLiterals(filterType(type, (t) => areTypesComparable(discriminantType, t)), discriminantType);
|
|
if (!hasDefaultClause) {
|
|
return caseType;
|
|
}
|
|
const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, getRegularTypeOfLiteralType(extractUnitType(t)))));
|
|
return caseType.flags & 131072 /* Never */ ? defaultType : getUnionType([caseType, defaultType]);
|
|
}
|
|
function narrowTypeByTypeName(type, typeName) {
|
|
switch (typeName) {
|
|
case "string":
|
|
return narrowTypeByTypeFacts(type, stringType, 1 /* TypeofEQString */);
|
|
case "number":
|
|
return narrowTypeByTypeFacts(type, numberType, 2 /* TypeofEQNumber */);
|
|
case "bigint":
|
|
return narrowTypeByTypeFacts(type, bigintType, 4 /* TypeofEQBigInt */);
|
|
case "boolean":
|
|
return narrowTypeByTypeFacts(type, booleanType, 8 /* TypeofEQBoolean */);
|
|
case "symbol":
|
|
return narrowTypeByTypeFacts(type, esSymbolType, 16 /* TypeofEQSymbol */);
|
|
case "object":
|
|
return type.flags & 1 /* Any */ ? type : getUnionType([narrowTypeByTypeFacts(type, nonPrimitiveType, 32 /* TypeofEQObject */), narrowTypeByTypeFacts(type, nullType, 131072 /* EQNull */)]);
|
|
case "function":
|
|
return type.flags & 1 /* Any */ ? type : narrowTypeByTypeFacts(type, globalFunctionType, 64 /* TypeofEQFunction */);
|
|
case "undefined":
|
|
return narrowTypeByTypeFacts(type, undefinedType, 65536 /* EQUndefined */);
|
|
}
|
|
return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
|
|
}
|
|
function narrowTypeByTypeFacts(type, impliedType, facts) {
|
|
return mapType(type, (t) => isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : isTypeSubtypeOf(impliedType, t) ? impliedType : getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType);
|
|
}
|
|
function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
|
|
const witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
|
|
if (!witnesses) {
|
|
return type;
|
|
}
|
|
const defaultIndex = findIndex(switchStatement.caseBlock.clauses, (clause) => clause.kind === 293 /* DefaultClause */);
|
|
const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
|
|
if (hasDefaultClause) {
|
|
const notEqualFacts = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
|
|
return filterType(type, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
|
|
}
|
|
const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
|
|
return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
|
|
}
|
|
function isMatchingConstructorReference(expr) {
|
|
return (isPropertyAccessExpression(expr) && idText(expr.name) === "constructor" || isElementAccessExpression(expr) && isStringLiteralLike(expr.argumentExpression) && expr.argumentExpression.text === "constructor") && isMatchingReference(reference, expr.expression);
|
|
}
|
|
function narrowTypeByConstructor(type, operator, identifier, assumeTrue) {
|
|
if (assumeTrue ? operator !== 34 /* EqualsEqualsToken */ && operator !== 36 /* EqualsEqualsEqualsToken */ : operator !== 35 /* ExclamationEqualsToken */ && operator !== 37 /* ExclamationEqualsEqualsToken */) {
|
|
return type;
|
|
}
|
|
const identifierType = getTypeOfExpression(identifier);
|
|
if (!isFunctionType(identifierType) && !isConstructorType(identifierType)) {
|
|
return type;
|
|
}
|
|
const prototypeProperty = getPropertyOfType(identifierType, "prototype");
|
|
if (!prototypeProperty) {
|
|
return type;
|
|
}
|
|
const prototypeType = getTypeOfSymbol(prototypeProperty);
|
|
const candidate = !isTypeAny(prototypeType) ? prototypeType : void 0;
|
|
if (!candidate || candidate === globalObjectType || candidate === globalFunctionType) {
|
|
return type;
|
|
}
|
|
if (isTypeAny(type)) {
|
|
return candidate;
|
|
}
|
|
return filterType(type, (t) => isConstructedBy(t, candidate));
|
|
function isConstructedBy(source, target) {
|
|
if (source.flags & 524288 /* Object */ && getObjectFlags(source) & 1 /* Class */ || target.flags & 524288 /* Object */ && getObjectFlags(target) & 1 /* Class */) {
|
|
return source.symbol === target.symbol;
|
|
}
|
|
return isTypeSubtypeOf(source, target);
|
|
}
|
|
}
|
|
function narrowTypeByInstanceof(type, expr, assumeTrue) {
|
|
const left = getReferenceCandidate(expr.left);
|
|
if (!isMatchingReference(reference, left)) {
|
|
if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
|
|
return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
return type;
|
|
}
|
|
const rightType = getTypeOfExpression(expr.right);
|
|
if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
|
|
return type;
|
|
}
|
|
let targetType;
|
|
const prototypeProperty = getPropertyOfType(rightType, "prototype");
|
|
if (prototypeProperty) {
|
|
const prototypePropertyType = getTypeOfSymbol(prototypeProperty);
|
|
if (!isTypeAny(prototypePropertyType)) {
|
|
targetType = prototypePropertyType;
|
|
}
|
|
}
|
|
if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
|
|
return type;
|
|
}
|
|
if (!targetType) {
|
|
const constructSignatures = getSignaturesOfType(rightType, 1 /* Construct */);
|
|
targetType = constructSignatures.length ? getUnionType(map(constructSignatures, (signature) => getReturnTypeOfSignature(getErasedSignature(signature)))) : emptyObjectType;
|
|
}
|
|
if (!assumeTrue && rightType.flags & 1048576 /* Union */) {
|
|
const nonConstructorTypeInUnion = find(rightType.types, (t) => !isConstructorType(t));
|
|
if (!nonConstructorTypeInUnion)
|
|
return type;
|
|
}
|
|
return getNarrowedType(type, targetType, assumeTrue, true);
|
|
}
|
|
function getNarrowedType(type, candidate, assumeTrue, checkDerived) {
|
|
var _a2;
|
|
const key2 = type.flags & 1048576 /* Union */ ? `N${getTypeId(type)},${getTypeId(candidate)},${(assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)}` : void 0;
|
|
return (_a2 = getCachedType(key2)) != null ? _a2 : setCachedType(key2, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
|
|
}
|
|
function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
|
|
const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
|
|
if (!assumeTrue) {
|
|
return filterType(type, (t) => !isRelated(t, candidate));
|
|
}
|
|
if (type.flags & 3 /* AnyOrUnknown */) {
|
|
return candidate;
|
|
}
|
|
const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
|
|
const narrowedType = mapType(candidate, (c) => {
|
|
const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
|
|
const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
|
|
const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
|
|
return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
|
|
});
|
|
return !(narrowedType.flags & 131072 /* 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)) {
|
|
const signature = assumeTrue || !isCallChain(callExpression) ? getEffectsSignature(callExpression) : void 0;
|
|
const predicate = signature && getTypePredicateOfSignature(signature);
|
|
if (predicate && (predicate.kind === 0 /* This */ || predicate.kind === 1 /* Identifier */)) {
|
|
return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue);
|
|
}
|
|
}
|
|
if (containsMissingType(type) && isAccessExpression(reference) && isPropertyAccessExpression(callExpression.expression)) {
|
|
const callAccess = callExpression.expression;
|
|
if (isMatchingReference(reference.expression, getReferenceCandidate(callAccess.expression)) && isIdentifier(callAccess.name) && callAccess.name.escapedText === "hasOwnProperty" && callExpression.arguments.length === 1) {
|
|
const argument = callExpression.arguments[0];
|
|
if (isStringLiteralLike(argument) && getAccessedPropertyName(reference) === escapeLeadingUnderscores(argument.text)) {
|
|
return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) {
|
|
if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) {
|
|
const predicateArgument = getTypePredicateArgument(predicate, callExpression);
|
|
if (predicateArgument) {
|
|
if (isMatchingReference(reference, predicateArgument)) {
|
|
return getNarrowedType(type, predicate.type, assumeTrue, false);
|
|
}
|
|
if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
|
|
type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(predicateArgument, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getNarrowedType(t, predicate.type, assumeTrue, false));
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowType(type, expr, assumeTrue) {
|
|
if (isExpressionOfOptionalChainRoot(expr) || isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 /* QuestionQuestionToken */ && expr.parent.left === expr) {
|
|
return narrowTypeByOptionality(type, expr, assumeTrue);
|
|
}
|
|
switch (expr.kind) {
|
|
case 79 /* Identifier */:
|
|
if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
|
|
inlineLevel++;
|
|
const result = narrowType(type, declaration.initializer, assumeTrue);
|
|
inlineLevel--;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return narrowTypeByTruthiness(type, expr, assumeTrue);
|
|
case 210 /* CallExpression */:
|
|
return narrowTypeByCallExpression(type, expr, assumeTrue);
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return narrowType(type, expr.expression, assumeTrue);
|
|
case 223 /* BinaryExpression */:
|
|
return narrowTypeByBinaryExpression(type, expr, assumeTrue);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
if (expr.operator === 53 /* ExclamationToken */) {
|
|
return narrowType(type, expr.operand, !assumeTrue);
|
|
}
|
|
break;
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByOptionality(type, expr, assumePresent) {
|
|
if (isMatchingReference(reference, expr)) {
|
|
return getAdjustedTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getTypeWithFacts(t, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */));
|
|
}
|
|
return type;
|
|
}
|
|
}
|
|
function getTypeOfSymbolAtLocation(symbol, location) {
|
|
symbol = symbol.exportSymbol || symbol;
|
|
if (location.kind === 79 /* Identifier */ || location.kind === 80 /* PrivateIdentifier */) {
|
|
if (isRightSideOfQualifiedNameOrPropertyAccess(location)) {
|
|
location = location.parent;
|
|
}
|
|
if (isExpressionNode(location) && (!isAssignmentTarget(location) || isWriteAccess(location))) {
|
|
const type = getTypeOfExpression(location);
|
|
if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
if (isDeclarationName(location) && isSetAccessor(location.parent) && getAnnotatedAccessorTypeNode(location.parent)) {
|
|
return getWriteTypeOfAccessors(location.parent.symbol);
|
|
}
|
|
return getNonMissingTypeOfSymbol(symbol);
|
|
}
|
|
function getControlFlowContainer(node) {
|
|
return findAncestor(node.parent, (node2) => isFunctionLike(node2) && !getImmediatelyInvokedFunctionExpression(node2) || node2.kind === 265 /* ModuleBlock */ || node2.kind === 308 /* SourceFile */ || node2.kind === 169 /* PropertyDeclaration */);
|
|
}
|
|
function isSymbolAssigned(symbol) {
|
|
if (!symbol.valueDeclaration) {
|
|
return false;
|
|
}
|
|
const parent = getRootDeclaration(symbol.valueDeclaration).parent;
|
|
const links = getNodeLinks(parent);
|
|
if (!(links.flags & 524288 /* AssignmentsMarked */)) {
|
|
links.flags |= 524288 /* AssignmentsMarked */;
|
|
if (!hasParentWithAssignmentsMarked(parent)) {
|
|
markNodeAssignments(parent);
|
|
}
|
|
}
|
|
return symbol.isAssigned || false;
|
|
}
|
|
function hasParentWithAssignmentsMarked(node) {
|
|
return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 524288 /* AssignmentsMarked */));
|
|
}
|
|
function markNodeAssignments(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
if (isAssignmentTarget(node)) {
|
|
const symbol = getResolvedSymbol(node);
|
|
if (isParameterOrCatchClauseVariable(symbol)) {
|
|
symbol.isAssigned = true;
|
|
}
|
|
}
|
|
} else {
|
|
forEachChild(node, markNodeAssignments);
|
|
}
|
|
}
|
|
function isConstVariable(symbol) {
|
|
return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */) !== 0;
|
|
}
|
|
function removeOptionalityFromDeclaredType(declaredType, declaration) {
|
|
if (pushTypeResolution(declaration.symbol, 2 /* DeclaredType */)) {
|
|
const annotationIncludesUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
|
|
popTypeResolution();
|
|
return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
|
|
} else {
|
|
reportCircularityError(declaration.symbol);
|
|
return declaredType;
|
|
}
|
|
}
|
|
function isConstraintPosition(type, node) {
|
|
const parent = node.parent;
|
|
return parent.kind === 208 /* PropertyAccessExpression */ || parent.kind === 163 /* QualifiedName */ || parent.kind === 210 /* CallExpression */ && parent.expression === node || parent.kind === 209 /* ElementAccessExpression */ && parent.expression === node && !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
|
|
}
|
|
function isGenericTypeWithUnionConstraint(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithUnionConstraint) : !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
|
|
}
|
|
function isGenericTypeWithoutNullableConstraint(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
|
|
}
|
|
function hasContextualTypeWithNoGenericTypes(node, checkMode) {
|
|
const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 64 /* RestBindingElement */ ? getContextualType(node, 8 /* SkipBindingPatterns */) : getContextualType(node, void 0));
|
|
return contextualType && !isGenericType(contextualType);
|
|
}
|
|
function getNarrowableTypeForReference(type, reference, checkMode) {
|
|
const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
|
|
return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
|
|
}
|
|
function isExportOrExportExpression(location) {
|
|
return !!findAncestor(location, (n) => {
|
|
const parent = n.parent;
|
|
if (parent === void 0) {
|
|
return "quit";
|
|
}
|
|
if (isExportAssignment(parent)) {
|
|
return parent.expression === n && isEntityNameExpression(n);
|
|
}
|
|
if (isExportSpecifier(parent)) {
|
|
return parent.name === n || parent.propertyName === n;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function markAliasReferenced(symbol, location) {
|
|
if (isNonLocalAlias(symbol, 111551 /* Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */)) {
|
|
const target = resolveAlias(symbol);
|
|
if (getAllSymbolFlags(target) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
|
|
if (compilerOptions.isolatedModules || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
|
|
markAliasSymbolAsReferenced(symbol);
|
|
} else {
|
|
markConstEnumAliasAsReferenced(symbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getNarrowedTypeOfSymbol(symbol, location) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration) {
|
|
if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
|
|
const parent = declaration.parent.parent;
|
|
if (parent.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 166 /* Parameter */) {
|
|
const links = getNodeLinks(parent);
|
|
if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
|
|
links.flags |= 16777216 /* InCheckIdentifier */;
|
|
const parentType = getTypeForBindingElementParent(parent, 0 /* Normal */);
|
|
const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
|
|
links.flags &= ~16777216 /* InCheckIdentifier */;
|
|
if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
|
|
const pattern = declaration.parent;
|
|
const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location.flowNode);
|
|
if (narrowedType.flags & 131072 /* Never */) {
|
|
return neverType;
|
|
}
|
|
return getBindingElementTypeFromParentType(declaration, narrowedType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isParameter(declaration) && !declaration.type && !declaration.initializer && !declaration.dotDotDotToken) {
|
|
const func = declaration.parent;
|
|
if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
|
|
const restType = getReducedApparentType(getTypeOfSymbol(contextualSignature.parameters[0]));
|
|
if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
|
|
const narrowedType = getFlowTypeOfReference(func, restType, restType, void 0, location.flowNode);
|
|
const index = func.parameters.indexOf(declaration) - (getThisParameter(func) ? 1 : 0);
|
|
return getIndexedAccessType(narrowedType, getNumberLiteralType(index));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
function checkIdentifier(node, checkMode) {
|
|
if (isThisInTypeQuery(node)) {
|
|
return checkThisExpression(node);
|
|
}
|
|
const symbol = getResolvedSymbol(node);
|
|
if (symbol === unknownSymbol) {
|
|
return errorType;
|
|
}
|
|
if (symbol === argumentsSymbol) {
|
|
if (isInPropertyInitializerOrClassStaticBlock(node)) {
|
|
error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
|
|
return errorType;
|
|
}
|
|
const container = getContainingFunction(node);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (container.kind === 216 /* ArrowFunction */) {
|
|
error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
|
|
} else if (hasSyntacticModifier(container, 512 /* Async */)) {
|
|
error(node, 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 |= 512 /* CaptureArguments */;
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (shouldMarkIdentifierAliasReferenced(node)) {
|
|
markAliasReferenced(symbol, node);
|
|
}
|
|
const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
|
|
const targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node);
|
|
if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
|
|
addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
|
|
}
|
|
let declaration = localOrExportSymbol.valueDeclaration;
|
|
if (declaration && localOrExportSymbol.flags & 32 /* Class */) {
|
|
if (declaration.kind === 260 /* ClassDeclaration */ && nodeIsDecorated(declaration)) {
|
|
let container = getContainingClass(node);
|
|
while (container !== void 0) {
|
|
if (container === declaration && container.name !== node) {
|
|
getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
|
|
getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
|
|
break;
|
|
}
|
|
container = getContainingClass(container);
|
|
}
|
|
} else if (declaration.kind === 228 /* ClassExpression */) {
|
|
let container = getThisContainer(node, false);
|
|
while (container.kind !== 308 /* SourceFile */) {
|
|
if (container.parent === declaration) {
|
|
if (isPropertyDeclaration(container) && isStatic(container) || isClassStaticBlockDeclaration(container)) {
|
|
getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
|
|
getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
|
|
}
|
|
break;
|
|
}
|
|
container = getThisContainer(container, false);
|
|
}
|
|
}
|
|
}
|
|
checkNestedBlockScopedBinding(node, symbol);
|
|
let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
if (assignmentKind) {
|
|
if (!(localOrExportSymbol.flags & 3 /* Variable */) && !(isInJSFile(node) && localOrExportSymbol.flags & 512 /* ValueModule */)) {
|
|
const assignmentError = localOrExportSymbol.flags & 384 /* Enum */ ? Diagnostics.Cannot_assign_to_0_because_it_is_an_enum : localOrExportSymbol.flags & 32 /* Class */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_class : localOrExportSymbol.flags & 1536 /* Module */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace : localOrExportSymbol.flags & 16 /* Function */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_function : localOrExportSymbol.flags & 2097152 /* Alias */ ? Diagnostics.Cannot_assign_to_0_because_it_is_an_import : 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 /* Variable */) {
|
|
error(node, Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol));
|
|
} else {
|
|
error(node, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol));
|
|
}
|
|
return errorType;
|
|
}
|
|
}
|
|
const isAlias = localOrExportSymbol.flags & 2097152 /* Alias */;
|
|
if (localOrExportSymbol.flags & 3 /* Variable */) {
|
|
if (assignmentKind === 1 /* Definite */) {
|
|
return type;
|
|
}
|
|
} else if (isAlias) {
|
|
declaration = getDeclarationOfAliasSymbol(symbol);
|
|
} else {
|
|
return type;
|
|
}
|
|
if (!declaration) {
|
|
return type;
|
|
}
|
|
type = getNarrowableTypeForReference(type, node, checkMode);
|
|
const isParameter2 = getRootDeclaration(declaration).kind === 166 /* Parameter */;
|
|
const declarationContainer = getControlFlowContainer(declaration);
|
|
let flowContainer = getControlFlowContainer(node);
|
|
const isOuterVariable = flowContainer !== declarationContainer;
|
|
const isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent);
|
|
const isModuleExports = symbol.flags & 134217728 /* ModuleExports */;
|
|
while (flowContainer !== declarationContainer && (flowContainer.kind === 215 /* FunctionExpression */ || flowContainer.kind === 216 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstVariable(localOrExportSymbol) && type !== autoArrayType || isParameter2 && !isSymbolAssigned(localOrExportSymbol))) {
|
|
flowContainer = getControlFlowContainer(flowContainer);
|
|
}
|
|
const assumeInitialized = isParameter2 || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || node.parent.kind === 278 /* ExportSpecifier */) || node.parent.kind === 232 /* NonNullExpression */ || declaration.kind === 257 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 16777216 /* Ambient */;
|
|
const initialType = assumeInitialized ? isParameter2 ? removeOptionalityFromDeclaredType(type, declaration) : type : type === autoType || type === autoArrayType ? undefinedType : getOptionalType(type);
|
|
const flowType = getFlowTypeOfReference(node, type, initialType, flowContainer);
|
|
if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) {
|
|
if (flowType === autoType || flowType === autoArrayType) {
|
|
if (noImplicitAny) {
|
|
error(getNameOfDeclaration(declaration), Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType));
|
|
error(node, Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
return convertAutoToAny(flowType);
|
|
}
|
|
} else if (!assumeInitialized && !containsUndefinedType(type) && containsUndefinedType(flowType)) {
|
|
error(node, Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
|
|
return type;
|
|
}
|
|
return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
|
|
}
|
|
function isSameScopedBindingElement(node, declaration) {
|
|
if (isBindingElement(declaration)) {
|
|
const bindingElement = findAncestor(node, isBindingElement);
|
|
return bindingElement && getRootDeclaration(bindingElement) === getRootDeclaration(declaration);
|
|
}
|
|
}
|
|
function shouldMarkIdentifierAliasReferenced(node) {
|
|
var _a2;
|
|
const parent = node.parent;
|
|
if (parent) {
|
|
if (isPropertyAccessExpression(parent) && parent.expression === node) {
|
|
return false;
|
|
}
|
|
if (isExportSpecifier(parent) && parent.isTypeOnly) {
|
|
return false;
|
|
}
|
|
const greatGrandparent = (_a2 = parent.parent) == null ? void 0 : _a2.parent;
|
|
if (greatGrandparent && isExportDeclaration(greatGrandparent) && greatGrandparent.isTypeOnly) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isInsideFunctionOrInstancePropertyInitializer(node, threshold) {
|
|
return !!findAncestor(node, (n) => n === threshold ? "quit" : isFunctionLike(n) || n.parent && isPropertyDeclaration(n.parent) && !hasStaticModifier(n.parent) && n.parent.initializer === n);
|
|
}
|
|
function getPartOfForStatementContainingNode(node, container) {
|
|
return findAncestor(node, (n) => n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement);
|
|
}
|
|
function getEnclosingIterationStatement(node) {
|
|
return findAncestor(node, (n) => !n || nodeStartsNewLexicalEnvironment(n) ? "quit" : isIterationStatement(n, false));
|
|
}
|
|
function checkNestedBlockScopedBinding(node, symbol) {
|
|
if (languageVersion >= 2 /* ES2015 */ || (symbol.flags & (2 /* BlockScopedVariable */ | 32 /* Class */)) === 0 || !symbol.valueDeclaration || isSourceFile(symbol.valueDeclaration) || symbol.valueDeclaration.parent.kind === 295 /* CatchClause */) {
|
|
return;
|
|
}
|
|
const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
|
|
const isCaptured = isInsideFunctionOrInstancePropertyInitializer(node, container);
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(container);
|
|
if (enclosingIterationStatement) {
|
|
if (isCaptured) {
|
|
let capturesBlockScopeBindingInLoopBody = true;
|
|
if (isForStatement(container)) {
|
|
const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
if (varDeclList && varDeclList.parent === container) {
|
|
const part = getPartOfForStatementContainingNode(node.parent, container);
|
|
if (part) {
|
|
const links = getNodeLinks(part);
|
|
links.flags |= 8192 /* ContainsCapturedBlockScopeBinding */;
|
|
const capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
|
|
pushIfUnique(capturedBindings, symbol);
|
|
if (part === container.initializer) {
|
|
capturesBlockScopeBindingInLoopBody = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (capturesBlockScopeBindingInLoopBody) {
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
if (isForStatement(container)) {
|
|
const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NeedsLoopOutParameter */;
|
|
}
|
|
}
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
}
|
|
if (isCaptured) {
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 16384 /* CapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
function isBindingCapturedByNode(node, decl) {
|
|
const links = getNodeLinks(node);
|
|
return !!links && contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl));
|
|
}
|
|
function isAssignedInBodyOfForStatement(node, container) {
|
|
let current = node;
|
|
while (current.parent.kind === 214 /* ParenthesizedExpression */) {
|
|
current = current.parent;
|
|
}
|
|
let isAssigned = false;
|
|
if (isAssignmentTarget(current)) {
|
|
isAssigned = true;
|
|
} else if (current.parent.kind === 221 /* PrefixUnaryExpression */ || current.parent.kind === 222 /* PostfixUnaryExpression */) {
|
|
const expr = current.parent;
|
|
isAssigned = expr.operator === 45 /* PlusPlusToken */ || expr.operator === 46 /* MinusMinusToken */;
|
|
}
|
|
if (!isAssigned) {
|
|
return false;
|
|
}
|
|
return !!findAncestor(current, (n) => n === container ? "quit" : n === container.statement);
|
|
}
|
|
function captureLexicalThis(node, container) {
|
|
getNodeLinks(node).flags |= 2 /* LexicalThis */;
|
|
if (container.kind === 169 /* PropertyDeclaration */ || container.kind === 173 /* Constructor */) {
|
|
const classNode = container.parent;
|
|
getNodeLinks(classNode).flags |= 4 /* CaptureThis */;
|
|
} else {
|
|
getNodeLinks(container).flags |= 4 /* CaptureThis */;
|
|
}
|
|
}
|
|
function findFirstSuperCall(node) {
|
|
return isSuperCall(node) ? node : isFunctionLike(node) ? void 0 : forEachChild(node, findFirstSuperCall);
|
|
}
|
|
function classDeclarationExtendsNull(classDecl) {
|
|
const classSymbol = getSymbolOfNode(classDecl);
|
|
const classInstanceType = getDeclaredTypeOfSymbol(classSymbol);
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType);
|
|
return baseConstructorType === nullWideningType;
|
|
}
|
|
function checkThisBeforeSuper(node, container, diagnosticMessage) {
|
|
const containingClassDecl = container.parent;
|
|
const baseTypeNode = getClassExtendsHeritageElement(containingClassDecl);
|
|
if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
|
|
if (node.flowNode && !isPostSuperFlowNode(node.flowNode, false)) {
|
|
error(node, diagnosticMessage);
|
|
}
|
|
}
|
|
}
|
|
function checkThisInStaticClassFieldInitializerInDecoratedClass(thisExpression, container) {
|
|
if (isPropertyDeclaration(container) && hasStaticModifier(container) && container.initializer && textRangeContainsPositionInclusive(container.initializer, thisExpression.pos) && hasDecorators(container.parent)) {
|
|
error(thisExpression, Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class);
|
|
}
|
|
}
|
|
function checkThisExpression(node) {
|
|
const isNodeInTypeQuery = isInTypeQuery(node);
|
|
let container = getThisContainer(node, true);
|
|
let capturedByArrowFunction = false;
|
|
if (container.kind === 173 /* Constructor */) {
|
|
checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class);
|
|
}
|
|
if (container.kind === 216 /* ArrowFunction */) {
|
|
container = getThisContainer(container, false);
|
|
capturedByArrowFunction = true;
|
|
}
|
|
checkThisInStaticClassFieldInitializerInDecoratedClass(node, container);
|
|
switch (container.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body);
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_current_location);
|
|
break;
|
|
case 173 /* Constructor */:
|
|
if (isInConstructorArgumentInitializer(node, container)) {
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_constructor_arguments);
|
|
}
|
|
break;
|
|
case 164 /* ComputedPropertyName */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
|
|
break;
|
|
}
|
|
if (!isNodeInTypeQuery && capturedByArrowFunction && languageVersion < 2 /* ES2015 */) {
|
|
captureLexicalThis(node, container);
|
|
}
|
|
const type = tryGetThisTypeAt(node, true, container);
|
|
if (noImplicitThis) {
|
|
const globalThisType2 = getTypeOfSymbol(globalThisSymbol);
|
|
if (type === globalThisType2 && capturedByArrowFunction) {
|
|
error(node, Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
|
|
} else if (!type) {
|
|
const diag2 = error(node, Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
|
|
if (!isSourceFile(container)) {
|
|
const outsideThis = tryGetThisTypeAt(container);
|
|
if (outsideThis && outsideThis !== globalThisType2) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(container, Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return type || anyType;
|
|
}
|
|
function tryGetThisTypeAt(node, includeGlobalThis = true, container = getThisContainer(node, false)) {
|
|
const isInJS = isInJSFile(node);
|
|
if (isFunctionLike(container) && (!isInParameterInitializerBeforeContainingFunction(node) || getThisParameter(container))) {
|
|
let thisType = getThisTypeOfDeclaration(container) || isInJS && getTypeForThisExpressionFromJSDoc(container);
|
|
if (!thisType) {
|
|
const className = getClassNameFromPrototypeMethod(container);
|
|
if (isInJS && className) {
|
|
const classSymbol = checkExpression(className).symbol;
|
|
if (classSymbol && classSymbol.members && classSymbol.flags & 16 /* 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 (isClassLike(container.parent)) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
const type = isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
|
|
return getFlowTypeOfReference(node, type);
|
|
}
|
|
if (isSourceFile(container)) {
|
|
if (container.commonJsModuleIndicator) {
|
|
const fileSymbol = getSymbolOfNode(container);
|
|
return fileSymbol && getTypeOfSymbol(fileSymbol);
|
|
} else if (container.externalModuleIndicator) {
|
|
return undefinedType;
|
|
} else if (includeGlobalThis) {
|
|
return getTypeOfSymbol(globalThisSymbol);
|
|
}
|
|
}
|
|
}
|
|
function getExplicitThisType(node) {
|
|
const container = getThisContainer(node, false);
|
|
if (isFunctionLike(container)) {
|
|
const signature = getSignatureFromDeclaration(container);
|
|
if (signature.thisParameter) {
|
|
return getExplicitTypeOfSymbol(signature.thisParameter);
|
|
}
|
|
}
|
|
if (isClassLike(container.parent)) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
return isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
|
|
}
|
|
}
|
|
function getClassNameFromPrototypeMethod(container) {
|
|
if (container.kind === 215 /* FunctionExpression */ && isBinaryExpression(container.parent) && getAssignmentDeclarationKind(container.parent) === 3 /* PrototypeProperty */) {
|
|
return container.parent.left.expression.expression;
|
|
} else if (container.kind === 171 /* MethodDeclaration */ && container.parent.kind === 207 /* ObjectLiteralExpression */ && isBinaryExpression(container.parent.parent) && getAssignmentDeclarationKind(container.parent.parent) === 6 /* Prototype */) {
|
|
return container.parent.parent.left.expression;
|
|
} else if (container.kind === 215 /* FunctionExpression */ && container.parent.kind === 299 /* PropertyAssignment */ && container.parent.parent.kind === 207 /* ObjectLiteralExpression */ && isBinaryExpression(container.parent.parent.parent) && getAssignmentDeclarationKind(container.parent.parent.parent) === 6 /* Prototype */) {
|
|
return container.parent.parent.parent.left.expression;
|
|
} else if (container.kind === 215 /* FunctionExpression */ && isPropertyAssignment(container.parent) && isIdentifier(container.parent.name) && (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") && isObjectLiteralExpression(container.parent.parent) && isCallExpression(container.parent.parent.parent) && container.parent.parent.parent.arguments[2] === container.parent.parent && getAssignmentDeclarationKind(container.parent.parent.parent) === 9 /* ObjectDefinePrototypeProperty */) {
|
|
return container.parent.parent.parent.arguments[0].expression;
|
|
} else if (isMethodDeclaration(container) && isIdentifier(container.name) && (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") && isObjectLiteralExpression(container.parent) && isCallExpression(container.parent.parent) && container.parent.parent.arguments[2] === container.parent && getAssignmentDeclarationKind(container.parent.parent) === 9 /* ObjectDefinePrototypeProperty */) {
|
|
return container.parent.parent.arguments[0].expression;
|
|
}
|
|
}
|
|
function getTypeForThisExpressionFromJSDoc(node) {
|
|
const jsdocType = getJSDocType(node);
|
|
if (jsdocType && jsdocType.kind === 320 /* JSDocFunctionType */) {
|
|
const jsDocFunctionType = jsdocType;
|
|
if (jsDocFunctionType.parameters.length > 0 && jsDocFunctionType.parameters[0].name && jsDocFunctionType.parameters[0].name.escapedText === "this" /* This */) {
|
|
return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
|
|
}
|
|
}
|
|
const thisTag = getJSDocThisTag(node);
|
|
if (thisTag && thisTag.typeExpression) {
|
|
return getTypeFromTypeNode(thisTag.typeExpression);
|
|
}
|
|
}
|
|
function isInConstructorArgumentInitializer(node, constructorDecl) {
|
|
return !!findAncestor(node, (n) => isFunctionLikeDeclaration(n) ? "quit" : n.kind === 166 /* Parameter */ && n.parent === constructorDecl);
|
|
}
|
|
function checkSuperExpression(node) {
|
|
const isCallExpression2 = node.parent.kind === 210 /* CallExpression */ && node.parent.expression === node;
|
|
const immediateContainer = getSuperContainer(node, true);
|
|
let container = immediateContainer;
|
|
let needToCaptureLexicalThis = false;
|
|
let inAsyncFunction = false;
|
|
if (!isCallExpression2) {
|
|
while (container && container.kind === 216 /* ArrowFunction */) {
|
|
if (hasSyntacticModifier(container, 512 /* Async */))
|
|
inAsyncFunction = true;
|
|
container = getSuperContainer(container, true);
|
|
needToCaptureLexicalThis = languageVersion < 2 /* ES2015 */;
|
|
}
|
|
if (container && hasSyntacticModifier(container, 512 /* Async */))
|
|
inAsyncFunction = true;
|
|
}
|
|
const canUseSuperExpression = isLegalUsageOfSuperExpression(container);
|
|
let nodeCheckFlag = 0;
|
|
if (!canUseSuperExpression) {
|
|
const current = findAncestor(node, (n) => n === container ? "quit" : n.kind === 164 /* ComputedPropertyName */);
|
|
if (current && current.kind === 164 /* ComputedPropertyName */) {
|
|
error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
|
|
} else if (isCallExpression2) {
|
|
error(node, Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
|
|
} else if (!container || !container.parent || !(isClassLike(container.parent) || container.parent.kind === 207 /* ObjectLiteralExpression */)) {
|
|
error(node, Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
|
|
} else {
|
|
error(node, Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (!isCallExpression2 && immediateContainer.kind === 173 /* Constructor */) {
|
|
checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
|
|
}
|
|
if (isStatic(container) || isCallExpression2) {
|
|
nodeCheckFlag = 32 /* SuperStatic */;
|
|
if (!isCallExpression2 && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && (isPropertyDeclaration(container) || isClassStaticBlockDeclaration(container))) {
|
|
forEachEnclosingBlockScopeContainer(node.parent, (current) => {
|
|
if (!isSourceFile(current) || isExternalOrCommonJsModule(current)) {
|
|
getNodeLinks(current).flags |= 8388608 /* ContainsSuperPropertyInStaticInitializer */;
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
nodeCheckFlag = 16 /* SuperInstance */;
|
|
}
|
|
getNodeLinks(node).flags |= nodeCheckFlag;
|
|
if (container.kind === 171 /* MethodDeclaration */ && inAsyncFunction) {
|
|
if (isSuperProperty(node.parent) && isAssignmentTarget(node.parent)) {
|
|
getNodeLinks(container).flags |= 256 /* MethodWithSuperPropertyAssignmentInAsync */;
|
|
} else {
|
|
getNodeLinks(container).flags |= 128 /* MethodWithSuperPropertyAccessInAsync */;
|
|
}
|
|
}
|
|
if (needToCaptureLexicalThis) {
|
|
captureLexicalThis(node.parent, container);
|
|
}
|
|
if (container.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
error(node, Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
|
|
return errorType;
|
|
} else {
|
|
return anyType;
|
|
}
|
|
}
|
|
const classLikeDeclaration = container.parent;
|
|
if (!getClassExtendsHeritageElement(classLikeDeclaration)) {
|
|
error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
|
|
return errorType;
|
|
}
|
|
const classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
|
|
const baseClassType = classType && getBaseTypes(classType)[0];
|
|
if (!baseClassType) {
|
|
return errorType;
|
|
}
|
|
if (container.kind === 173 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) {
|
|
error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
|
|
return errorType;
|
|
}
|
|
return nodeCheckFlag === 32 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
|
|
function isLegalUsageOfSuperExpression(container2) {
|
|
if (!container2) {
|
|
return false;
|
|
}
|
|
if (isCallExpression2) {
|
|
return container2.kind === 173 /* Constructor */;
|
|
} else {
|
|
if (isClassLike(container2.parent) || container2.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (isStatic(container2)) {
|
|
return container2.kind === 171 /* MethodDeclaration */ || container2.kind === 170 /* MethodSignature */ || container2.kind === 174 /* GetAccessor */ || container2.kind === 175 /* SetAccessor */ || container2.kind === 169 /* PropertyDeclaration */ || container2.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
} else {
|
|
return container2.kind === 171 /* MethodDeclaration */ || container2.kind === 170 /* MethodSignature */ || container2.kind === 174 /* GetAccessor */ || container2.kind === 175 /* SetAccessor */ || container2.kind === 169 /* PropertyDeclaration */ || container2.kind === 168 /* PropertySignature */ || container2.kind === 173 /* Constructor */;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getContainingObjectLiteral(func) {
|
|
return (func.kind === 171 /* MethodDeclaration */ || func.kind === 174 /* GetAccessor */ || func.kind === 175 /* SetAccessor */) && func.parent.kind === 207 /* ObjectLiteralExpression */ ? func.parent : func.kind === 215 /* FunctionExpression */ && func.parent.kind === 299 /* PropertyAssignment */ ? func.parent.parent : void 0;
|
|
}
|
|
function getThisTypeArgument(type) {
|
|
return getObjectFlags(type) & 4 /* Reference */ && type.target === globalThisType ? getTypeArguments(type)[0] : void 0;
|
|
}
|
|
function getThisTypeFromContextualType(type) {
|
|
return mapType(type, (t) => {
|
|
return t.flags & 2097152 /* Intersection */ ? forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
|
|
});
|
|
}
|
|
function getContextualThisParameterType(func) {
|
|
if (func.kind === 216 /* ArrowFunction */) {
|
|
return void 0;
|
|
}
|
|
if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature) {
|
|
const thisParameter = contextualSignature.thisParameter;
|
|
if (thisParameter) {
|
|
return getTypeOfSymbol(thisParameter);
|
|
}
|
|
}
|
|
}
|
|
const inJs = isInJSFile(func);
|
|
if (noImplicitThis || inJs) {
|
|
const containingLiteral = getContainingObjectLiteral(func);
|
|
if (containingLiteral) {
|
|
const contextualType = getApparentTypeOfContextualType(containingLiteral, void 0);
|
|
let literal = containingLiteral;
|
|
let type = contextualType;
|
|
while (type) {
|
|
const thisType = getThisTypeFromContextualType(type);
|
|
if (thisType) {
|
|
return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
|
|
}
|
|
if (literal.parent.kind !== 299 /* PropertyAssignment */) {
|
|
break;
|
|
}
|
|
literal = literal.parent.parent;
|
|
type = getApparentTypeOfContextualType(literal, void 0);
|
|
}
|
|
return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
|
|
}
|
|
const parent = walkUpParenthesizedExpressions(func.parent);
|
|
if (parent.kind === 223 /* BinaryExpression */ && parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const target = parent.left;
|
|
if (isAccessExpression(target)) {
|
|
const { expression } = target;
|
|
if (inJs && isIdentifier(expression)) {
|
|
const sourceFile = getSourceFileOfNode(parent);
|
|
if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return getWidenedType(checkExpressionCached(expression));
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextuallyTypedParameterType(parameter) {
|
|
const func = parameter.parent;
|
|
if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
return void 0;
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(func);
|
|
if (iife && iife.arguments) {
|
|
const args = getEffectiveCallArguments(iife);
|
|
const indexOfParameter = func.parameters.indexOf(parameter);
|
|
if (parameter.dotDotDotToken) {
|
|
return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, void 0, 0 /* Normal */);
|
|
}
|
|
const links = getNodeLinks(iife);
|
|
const cached = links.resolvedSignature;
|
|
links.resolvedSignature = anySignature;
|
|
const type = indexOfParameter < args.length ? getWidenedLiteralType(checkExpression(args[indexOfParameter])) : parameter.initializer ? void 0 : undefinedWideningType;
|
|
links.resolvedSignature = cached;
|
|
return type;
|
|
}
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature) {
|
|
const index = func.parameters.indexOf(parameter) - (getThisParameter(func) ? 1 : 0);
|
|
return parameter.dotDotDotToken && lastOrUndefined(func.parameters) === parameter ? getRestTypeAtPosition(contextualSignature, index) : tryGetTypeAtPosition(contextualSignature, index);
|
|
}
|
|
}
|
|
function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(declaration);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
switch (declaration.kind) {
|
|
case 166 /* Parameter */:
|
|
return getContextuallyTypedParameterType(declaration);
|
|
case 205 /* BindingElement */:
|
|
return getContextualTypeForBindingElement(declaration, contextFlags);
|
|
case 169 /* PropertyDeclaration */:
|
|
if (isStatic(declaration)) {
|
|
return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags);
|
|
}
|
|
}
|
|
}
|
|
function getContextualTypeForBindingElement(declaration, contextFlags) {
|
|
const parent = declaration.parent.parent;
|
|
const name = declaration.propertyName || declaration.name;
|
|
const parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) || parent.kind !== 205 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
|
|
if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name))
|
|
return void 0;
|
|
if (parent.name.kind === 204 /* ArrayBindingPattern */) {
|
|
const index = indexOfNode(declaration.parent.elements, declaration);
|
|
if (index < 0)
|
|
return void 0;
|
|
return getContextualTypeForElementExpression(parentType, index);
|
|
}
|
|
const nameType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(nameType)) {
|
|
const text = getPropertyNameFromType(nameType);
|
|
return getTypeOfPropertyOfType(parentType, text);
|
|
}
|
|
}
|
|
function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) {
|
|
const parentType = isExpression(declaration.parent) && getContextualType(declaration.parent, contextFlags);
|
|
if (!parentType)
|
|
return void 0;
|
|
return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
|
|
}
|
|
function getContextualTypeForInitializerExpression(node, contextFlags) {
|
|
const declaration = node.parent;
|
|
if (hasInitializer(declaration) && node === declaration.initializer) {
|
|
const result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
if (!(contextFlags & 8 /* SkipBindingPatterns */) && isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
|
|
return getTypeFromBindingPattern(declaration.name, true, false);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForReturnExpression(node, contextFlags) {
|
|
const func = getContainingFunction(node);
|
|
if (func) {
|
|
let contextualReturnType = getContextualReturnType(func, contextFlags);
|
|
if (contextualReturnType) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
if (functionFlags & 1 /* Generator */) {
|
|
const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
|
|
if (contextualReturnType.flags & 1048576 /* Union */) {
|
|
contextualReturnType = filterType(contextualReturnType, (type) => !!getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, type, isAsyncGenerator));
|
|
}
|
|
const iterationReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, contextualReturnType, (functionFlags & 2 /* Async */) !== 0);
|
|
if (!iterationReturnType) {
|
|
return void 0;
|
|
}
|
|
contextualReturnType = iterationReturnType;
|
|
}
|
|
if (functionFlags & 2 /* Async */) {
|
|
const contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeNoAlias);
|
|
return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
|
|
}
|
|
return contextualReturnType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForAwaitOperand(node, contextFlags) {
|
|
const contextualType = getContextualType(node, contextFlags);
|
|
if (contextualType) {
|
|
const contextualAwaitedType = getAwaitedTypeNoAlias(contextualType);
|
|
return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForYieldOperand(node, contextFlags) {
|
|
const func = getContainingFunction(node);
|
|
if (func) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
let contextualReturnType = getContextualReturnType(func, contextFlags);
|
|
if (contextualReturnType) {
|
|
const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
|
|
if (!node.asteriskToken && contextualReturnType.flags & 1048576 /* Union */) {
|
|
contextualReturnType = filterType(contextualReturnType, (type) => !!getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, type, isAsyncGenerator));
|
|
}
|
|
return node.asteriskToken ? contextualReturnType : getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, contextualReturnType, isAsyncGenerator);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isInParameterInitializerBeforeContainingFunction(node) {
|
|
let inBindingInitializer = false;
|
|
while (node.parent && !isFunctionLike(node.parent)) {
|
|
if (isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) {
|
|
return true;
|
|
}
|
|
if (isBindingElement(node.parent) && node.parent.initializer === node) {
|
|
inBindingInitializer = true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function getContextualIterationType(kind, functionDecl) {
|
|
const isAsync = !!(getFunctionFlags(functionDecl) & 2 /* Async */);
|
|
const contextualReturnType = getContextualReturnType(functionDecl, void 0);
|
|
if (contextualReturnType) {
|
|
return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync) || void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualReturnType(functionDecl, contextFlags) {
|
|
const returnType = getReturnTypeFromAnnotation(functionDecl);
|
|
if (returnType) {
|
|
return returnType;
|
|
}
|
|
const signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
|
|
if (signature && !isResolvingReturnTypeOfSignature(signature)) {
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(functionDecl);
|
|
if (iife) {
|
|
return getContextualType(iife, contextFlags);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForArgument(callTarget, arg) {
|
|
const args = getEffectiveCallArguments(callTarget);
|
|
const argIndex = args.indexOf(arg);
|
|
return argIndex === -1 ? void 0 : getContextualTypeForArgumentAtIndex(callTarget, argIndex);
|
|
}
|
|
function getContextualTypeForArgumentAtIndex(callTarget, argIndex) {
|
|
if (isImportCall(callTarget)) {
|
|
return argIndex === 0 ? stringType : argIndex === 1 ? getGlobalImportCallOptionsType(false) : anyType;
|
|
}
|
|
const signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
|
|
if (isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
|
|
return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
|
|
}
|
|
const restIndex = signature.parameters.length - 1;
|
|
return signatureHasRestParameter(signature) && argIndex >= restIndex ? getIndexedAccessType(getTypeOfSymbol(signature.parameters[restIndex]), getNumberLiteralType(argIndex - restIndex), 256 /* Contextual */) : getTypeAtPosition(signature, argIndex);
|
|
}
|
|
function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
|
|
if (template.parent.kind === 212 /* TaggedTemplateExpression */) {
|
|
return getContextualTypeForArgument(template.parent, substitutionExpression);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForBinaryOperand(node, contextFlags) {
|
|
const binaryExpression = node.parent;
|
|
const { left, operatorToken, right } = binaryExpression;
|
|
switch (operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return node === right ? getContextualTypeForAssignmentDeclaration(binaryExpression) : void 0;
|
|
case 56 /* BarBarToken */:
|
|
case 60 /* QuestionQuestionToken */:
|
|
const type = getContextualType(binaryExpression, contextFlags);
|
|
return node === right && (type && type.pattern || !type && !isDefaultedExpandoInitializer(binaryExpression)) ? getTypeOfExpression(left) : type;
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 27 /* CommaToken */:
|
|
return node === right ? getContextualType(binaryExpression, contextFlags) : void 0;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getSymbolForExpression(e) {
|
|
if (e.symbol) {
|
|
return e.symbol;
|
|
}
|
|
if (isIdentifier(e)) {
|
|
return getResolvedSymbol(e);
|
|
}
|
|
if (isPropertyAccessExpression(e)) {
|
|
const lhsType = getTypeOfExpression(e.expression);
|
|
return isPrivateIdentifier(e.name) ? tryGetPrivateIdentifierPropertyOfType(lhsType, e.name) : getPropertyOfType(lhsType, e.name.escapedText);
|
|
}
|
|
if (isElementAccessExpression(e)) {
|
|
const propType = checkExpressionCached(e.argumentExpression);
|
|
if (!isTypeUsableAsPropertyName(propType)) {
|
|
return void 0;
|
|
}
|
|
const lhsType = getTypeOfExpression(e.expression);
|
|
return getPropertyOfType(lhsType, getPropertyNameFromType(propType));
|
|
}
|
|
return void 0;
|
|
function tryGetPrivateIdentifierPropertyOfType(type, id) {
|
|
const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(id.escapedText, id);
|
|
return lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(type, lexicallyScopedSymbol);
|
|
}
|
|
}
|
|
function getContextualTypeForAssignmentDeclaration(binaryExpression) {
|
|
var _a2, _b;
|
|
const kind = getAssignmentDeclarationKind(binaryExpression);
|
|
switch (kind) {
|
|
case 0 /* None */:
|
|
case 4 /* ThisProperty */:
|
|
const lhsSymbol = getSymbolForExpression(binaryExpression.left);
|
|
const decl = lhsSymbol && lhsSymbol.valueDeclaration;
|
|
if (decl && (isPropertyDeclaration(decl) || isPropertySignature(decl))) {
|
|
const overallAnnotation = getEffectiveTypeAnnotationNode(decl);
|
|
return overallAnnotation && instantiateType(getTypeFromTypeNode(overallAnnotation), getSymbolLinks(lhsSymbol).mapper) || (isPropertyDeclaration(decl) ? decl.initializer && getTypeOfExpression(binaryExpression.left) : void 0);
|
|
}
|
|
if (kind === 0 /* None */) {
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
}
|
|
return getContextualTypeForThisPropertyAssignment(binaryExpression);
|
|
case 5 /* Property */:
|
|
if (isPossiblyAliasedThisProperty(binaryExpression, kind)) {
|
|
return getContextualTypeForThisPropertyAssignment(binaryExpression);
|
|
} else if (!binaryExpression.left.symbol) {
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
} else {
|
|
const decl2 = binaryExpression.left.symbol.valueDeclaration;
|
|
if (!decl2) {
|
|
return void 0;
|
|
}
|
|
const lhs = cast(binaryExpression.left, isAccessExpression);
|
|
const overallAnnotation = getEffectiveTypeAnnotationNode(decl2);
|
|
if (overallAnnotation) {
|
|
return getTypeFromTypeNode(overallAnnotation);
|
|
} else if (isIdentifier(lhs.expression)) {
|
|
const id = lhs.expression;
|
|
const parentSymbol = resolveName(id, id.escapedText, 111551 /* Value */, void 0, id.escapedText, true);
|
|
if (parentSymbol) {
|
|
const annotated2 = parentSymbol.valueDeclaration && getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration);
|
|
if (annotated2) {
|
|
const nameStr = getElementOrPropertyAccessName(lhs);
|
|
if (nameStr !== void 0) {
|
|
return getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated2), nameStr);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
return isInJSFile(decl2) ? void 0 : getTypeOfExpression(binaryExpression.left);
|
|
}
|
|
case 1 /* ExportsProperty */:
|
|
case 6 /* Prototype */:
|
|
case 3 /* PrototypeProperty */:
|
|
case 2 /* ModuleExports */:
|
|
let valueDeclaration;
|
|
if (kind !== 2 /* ModuleExports */) {
|
|
valueDeclaration = (_a2 = binaryExpression.left.symbol) == null ? void 0 : _a2.valueDeclaration;
|
|
}
|
|
valueDeclaration || (valueDeclaration = (_b = binaryExpression.symbol) == null ? void 0 : _b.valueDeclaration);
|
|
const annotated = valueDeclaration && getEffectiveTypeAnnotationNode(valueDeclaration);
|
|
return annotated ? getTypeFromTypeNode(annotated) : void 0;
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return Debug.fail("Does not apply");
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function isPossiblyAliasedThisProperty(declaration, kind = getAssignmentDeclarationKind(declaration)) {
|
|
if (kind === 4 /* ThisProperty */) {
|
|
return true;
|
|
}
|
|
if (!isInJSFile(declaration) || kind !== 5 /* Property */ || !isIdentifier(declaration.left.expression)) {
|
|
return false;
|
|
}
|
|
const name = declaration.left.expression.escapedText;
|
|
const symbol = resolveName(declaration.left, name, 111551 /* Value */, void 0, void 0, true, true);
|
|
return isThisInitializedDeclaration(symbol == null ? void 0 : symbol.valueDeclaration);
|
|
}
|
|
function getContextualTypeForThisPropertyAssignment(binaryExpression) {
|
|
if (!binaryExpression.symbol)
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
if (binaryExpression.symbol.valueDeclaration) {
|
|
const annotated = getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration);
|
|
if (annotated) {
|
|
const type = getTypeFromTypeNode(annotated);
|
|
if (type) {
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
const thisAccess = cast(binaryExpression.left, isAccessExpression);
|
|
if (!isObjectLiteralMethod(getThisContainer(thisAccess.expression, false))) {
|
|
return void 0;
|
|
}
|
|
const thisType = checkThisExpression(thisAccess.expression);
|
|
const nameStr = getElementOrPropertyAccessName(thisAccess);
|
|
return nameStr !== void 0 && getTypeOfPropertyOfContextualType(thisType, nameStr) || void 0;
|
|
}
|
|
function isCircularMappedProperty(symbol) {
|
|
return !!(getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
|
|
}
|
|
function getTypeOfPropertyOfContextualType(type, name, nameType) {
|
|
return mapType(type, (t) => {
|
|
var _a2;
|
|
if (isGenericMappedType(t) && !t.declaration.nameType) {
|
|
const constraint = getConstraintTypeFromMappedType(t);
|
|
const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
|
|
const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
|
|
if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
|
|
return substituteIndexedMappedType(t, propertyNameType);
|
|
}
|
|
} else if (t.flags & 3670016 /* StructuredType */) {
|
|
const prop = getPropertyOfType(t, name);
|
|
if (prop) {
|
|
return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
|
|
}
|
|
if (isTupleType(t)) {
|
|
const restType = getRestTypeOfTupleType(t);
|
|
if (restType && isNumericLiteralName(name) && +name >= 0) {
|
|
return restType;
|
|
}
|
|
}
|
|
return (_a2 = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a2.type;
|
|
}
|
|
return void 0;
|
|
}, true);
|
|
}
|
|
function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
|
|
Debug.assert(isObjectLiteralMethod(node));
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
return getContextualTypeForObjectLiteralElement(node, contextFlags);
|
|
}
|
|
function getContextualTypeForObjectLiteralElement(element, contextFlags) {
|
|
const objectLiteral = element.parent;
|
|
const propertyAssignmentType = isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags);
|
|
if (propertyAssignmentType) {
|
|
return propertyAssignmentType;
|
|
}
|
|
const type = getApparentTypeOfContextualType(objectLiteral, contextFlags);
|
|
if (type) {
|
|
if (hasBindableName(element)) {
|
|
const symbol = getSymbolOfNode(element);
|
|
return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
|
|
}
|
|
if (element.name) {
|
|
const nameType = getLiteralTypeFromPropertyName(element.name);
|
|
return mapType(type, (t) => {
|
|
var _a2;
|
|
return (_a2 = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType)) == null ? void 0 : _a2.type;
|
|
}, true);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForElementExpression(arrayContextualType, index) {
|
|
return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
|
|
arrayContextualType,
|
|
(t) => getIteratedTypeOrElementType(1 /* Element */, t, undefinedType, void 0, false),
|
|
true
|
|
));
|
|
}
|
|
function getContextualTypeForConditionalOperand(node, contextFlags) {
|
|
const conditional = node.parent;
|
|
return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : void 0;
|
|
}
|
|
function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
|
|
const attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
|
|
const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
|
|
return void 0;
|
|
}
|
|
const realChildren = getSemanticJsxChildren(node.children);
|
|
const childIndex = realChildren.indexOf(child);
|
|
const childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName);
|
|
return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, (t) => {
|
|
if (isArrayLikeType(t)) {
|
|
return getIndexedAccessType(t, getNumberLiteralType(childIndex));
|
|
} else {
|
|
return t;
|
|
}
|
|
}, true));
|
|
}
|
|
function getContextualTypeForJsxExpression(node, contextFlags) {
|
|
const exprParent = node.parent;
|
|
return isJsxAttributeLike(exprParent) ? getContextualType(node, contextFlags) : isJsxElement(exprParent) ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags) : void 0;
|
|
}
|
|
function getContextualTypeForJsxAttribute(attribute, contextFlags) {
|
|
if (isJsxAttribute(attribute)) {
|
|
const attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
|
|
if (!attributesType || isTypeAny(attributesType)) {
|
|
return void 0;
|
|
}
|
|
return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
|
|
} else {
|
|
return getContextualType(attribute.parent, contextFlags);
|
|
}
|
|
}
|
|
function isPossiblyDiscriminantValue(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 79 /* Identifier */:
|
|
case 155 /* UndefinedKeyword */:
|
|
return true;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isPossiblyDiscriminantValue(node.expression);
|
|
case 291 /* JsxExpression */:
|
|
return !node.expression || isPossiblyDiscriminantValue(node.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function discriminateContextualTypeByObjectMembers(node, contextualType) {
|
|
return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(
|
|
contextualType,
|
|
concatenate(
|
|
map(
|
|
filter(node.properties, (p) => !!p.symbol && p.kind === 299 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName)),
|
|
(prop) => [() => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
|
|
),
|
|
map(
|
|
filter(getPropertiesOfType(contextualType), (s) => {
|
|
var _a2;
|
|
return !!(s.flags & 16777216 /* Optional */) && !!((_a2 = node == null ? void 0 : node.symbol) == null ? void 0 : _a2.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
|
|
}),
|
|
(s) => [() => undefinedType, s.escapedName]
|
|
)
|
|
),
|
|
isTypeAssignableTo,
|
|
contextualType
|
|
);
|
|
}
|
|
function discriminateContextualTypeByJSXAttributes(node, contextualType) {
|
|
return discriminateTypeByDiscriminableItems(
|
|
contextualType,
|
|
concatenate(
|
|
map(
|
|
filter(node.properties, (p) => !!p.symbol && p.kind === 288 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
|
|
(prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
|
|
),
|
|
map(
|
|
filter(getPropertiesOfType(contextualType), (s) => {
|
|
var _a2;
|
|
return !!(s.flags & 16777216 /* Optional */) && !!((_a2 = node == null ? void 0 : node.symbol) == null ? void 0 : _a2.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
|
|
}),
|
|
(s) => [() => undefinedType, s.escapedName]
|
|
)
|
|
),
|
|
isTypeAssignableTo,
|
|
contextualType
|
|
);
|
|
}
|
|
function getApparentTypeOfContextualType(node, contextFlags) {
|
|
const contextualType = isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node, contextFlags) : getContextualType(node, contextFlags);
|
|
const instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
|
|
if (instantiatedType && !(contextFlags && contextFlags & 2 /* NoConstraints */ && instantiatedType.flags & 8650752 /* TypeVariable */)) {
|
|
const apparentType = mapType(instantiatedType, getApparentType, true);
|
|
return apparentType.flags & 1048576 /* Union */ && isObjectLiteralExpression(node) ? discriminateContextualTypeByObjectMembers(node, apparentType) : apparentType.flags & 1048576 /* Union */ && isJsxAttributes(node) ? discriminateContextualTypeByJSXAttributes(node, apparentType) : apparentType;
|
|
}
|
|
}
|
|
function instantiateContextualType(contextualType, node, contextFlags) {
|
|
if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* Instantiable */)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
if (inferenceContext && contextFlags & 1 /* Signature */ && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
|
|
return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
|
|
}
|
|
if (inferenceContext == null ? void 0 : inferenceContext.returnMapper) {
|
|
const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
|
|
return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ? filterType(type, (t) => t !== regularFalseType && t !== regularTrueType) : type;
|
|
}
|
|
}
|
|
return contextualType;
|
|
}
|
|
function instantiateInstantiableTypes(type, mapper) {
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
return instantiateType(type, mapper);
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return getUnionType(map(type.types, (t) => instantiateInstantiableTypes(t, mapper)), 0 /* None */);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(map(type.types, (t) => instantiateInstantiableTypes(t, mapper)));
|
|
}
|
|
return type;
|
|
}
|
|
function getContextualType(node, contextFlags) {
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
if (node.contextualType) {
|
|
return node.contextualType;
|
|
}
|
|
const { parent } = node;
|
|
switch (parent.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 205 /* BindingElement */:
|
|
return getContextualTypeForInitializerExpression(node, contextFlags);
|
|
case 216 /* ArrowFunction */:
|
|
case 250 /* ReturnStatement */:
|
|
return getContextualTypeForReturnExpression(node, contextFlags);
|
|
case 226 /* YieldExpression */:
|
|
return getContextualTypeForYieldOperand(parent, contextFlags);
|
|
case 220 /* AwaitExpression */:
|
|
return getContextualTypeForAwaitOperand(parent, contextFlags);
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return getContextualTypeForArgument(parent, node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return isConstTypeReference(parent.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(parent.type);
|
|
case 223 /* BinaryExpression */:
|
|
return getContextualTypeForBinaryOperand(node, contextFlags);
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return getContextualTypeForObjectLiteralElement(parent, contextFlags);
|
|
case 301 /* SpreadAssignment */:
|
|
return getContextualType(parent.parent, contextFlags);
|
|
case 206 /* ArrayLiteralExpression */: {
|
|
const arrayLiteral = parent;
|
|
const type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
|
|
return getContextualTypeForElementExpression(type, indexOfNode(arrayLiteral.elements, node));
|
|
}
|
|
case 224 /* ConditionalExpression */:
|
|
return getContextualTypeForConditionalOperand(node, contextFlags);
|
|
case 236 /* TemplateSpan */:
|
|
Debug.assert(parent.parent.kind === 225 /* TemplateExpression */);
|
|
return getContextualTypeForSubstitutionExpression(parent.parent, node);
|
|
case 214 /* ParenthesizedExpression */: {
|
|
const tag = isInJSFile(parent) ? getJSDocTypeTag(parent) : void 0;
|
|
return !tag ? getContextualType(parent, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(tag.typeExpression.type);
|
|
}
|
|
case 232 /* NonNullExpression */:
|
|
return getContextualType(parent, contextFlags);
|
|
case 235 /* SatisfiesExpression */:
|
|
return getTypeFromTypeNode(parent.type);
|
|
case 274 /* ExportAssignment */:
|
|
return tryGetTypeFromEffectiveTypeNode(parent);
|
|
case 291 /* JsxExpression */:
|
|
return getContextualTypeForJsxExpression(parent, contextFlags);
|
|
case 288 /* JsxAttribute */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
return getContextualTypeForJsxAttribute(parent, contextFlags);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return getContextualJsxElementAttributesType(parent, contextFlags);
|
|
}
|
|
return void 0;
|
|
function tryFindWhenConstTypeReference(node2) {
|
|
return getContextualType(node2, contextFlags);
|
|
}
|
|
}
|
|
function getInferenceContext(node) {
|
|
const ancestor = findAncestor(node, (n) => !!n.inferenceContext);
|
|
return ancestor && ancestor.inferenceContext;
|
|
}
|
|
function getContextualJsxElementAttributesType(node, contextFlags) {
|
|
if (isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4 /* Completions */) {
|
|
return node.parent.contextualType;
|
|
}
|
|
return getContextualTypeForArgumentAtIndex(node, 0);
|
|
}
|
|
function getEffectiveFirstArgumentForJsxSignature(signature, node) {
|
|
return getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node);
|
|
}
|
|
function getJsxPropsTypeFromCallSignature(sig, context) {
|
|
let propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
|
|
propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
|
|
const intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
|
|
if (!isErrorType(intrinsicAttribs)) {
|
|
propsType = intersectTypes(intrinsicAttribs, propsType);
|
|
}
|
|
return propsType;
|
|
}
|
|
function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) {
|
|
if (sig.compositeSignatures) {
|
|
const results = [];
|
|
for (const signature of sig.compositeSignatures) {
|
|
const instance = getReturnTypeOfSignature(signature);
|
|
if (isTypeAny(instance)) {
|
|
return instance;
|
|
}
|
|
const propType = getTypeOfPropertyOfType(instance, forcedLookupLocation);
|
|
if (!propType) {
|
|
return;
|
|
}
|
|
results.push(propType);
|
|
}
|
|
return getIntersectionType(results);
|
|
}
|
|
const instanceType = getReturnTypeOfSignature(sig);
|
|
return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
|
|
}
|
|
function getStaticTypeOfReferencedJsxConstructor(context) {
|
|
if (isJsxIntrinsicIdentifier(context.tagName)) {
|
|
const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context);
|
|
const fakeSignature = createSignatureForJSXIntrinsic(context, result);
|
|
return getOrCreateTypeFromSignature(fakeSignature);
|
|
}
|
|
const tagType = checkExpressionCached(context.tagName);
|
|
if (tagType.flags & 128 /* StringLiteral */) {
|
|
const result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context);
|
|
if (!result) {
|
|
return errorType;
|
|
}
|
|
const fakeSignature = createSignatureForJSXIntrinsic(context, result);
|
|
return getOrCreateTypeFromSignature(fakeSignature);
|
|
}
|
|
return tagType;
|
|
}
|
|
function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
|
|
const managedSym = getJsxLibraryManagedAttributes(ns);
|
|
if (managedSym) {
|
|
const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
|
|
const ctorType = getStaticTypeOfReferencedJsxConstructor(context);
|
|
if (managedSym.flags & 524288 /* TypeAlias */) {
|
|
const params = getSymbolLinks(managedSym).typeParameters;
|
|
if (length(params) >= 2) {
|
|
const args = fillMissingTypeArguments([ctorType, attributesType], params, 2, isInJSFile(context));
|
|
return getTypeAliasInstantiation(managedSym, args);
|
|
}
|
|
}
|
|
if (length(declaredManagedType.typeParameters) >= 2) {
|
|
const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, isInJSFile(context));
|
|
return createTypeReference(declaredManagedType, args);
|
|
}
|
|
}
|
|
return attributesType;
|
|
}
|
|
function getJsxPropsTypeFromClassType(sig, context) {
|
|
const ns = getJsxNamespaceAt(context);
|
|
const forcedLookupLocation = getJsxElementPropertiesName(ns);
|
|
let attributesType = forcedLookupLocation === void 0 ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType) : forcedLookupLocation === "" ? getReturnTypeOfSignature(sig) : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation);
|
|
if (!attributesType) {
|
|
if (!!forcedLookupLocation && !!length(context.attributes.properties)) {
|
|
error(context, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, unescapeLeadingUnderscores(forcedLookupLocation));
|
|
}
|
|
return unknownType;
|
|
}
|
|
attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType);
|
|
if (isTypeAny(attributesType)) {
|
|
return attributesType;
|
|
} else {
|
|
let apparentAttributesType = attributesType;
|
|
const intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
|
|
if (!isErrorType(intrinsicClassAttribs)) {
|
|
const typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
|
|
const hostClassType = getReturnTypeOfSignature(sig);
|
|
let libraryManagedAttributeType;
|
|
if (typeParams) {
|
|
const inferredArgs = fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), isInJSFile(context));
|
|
libraryManagedAttributeType = instantiateType(intrinsicClassAttribs, createTypeMapper(typeParams, inferredArgs));
|
|
} else
|
|
libraryManagedAttributeType = intrinsicClassAttribs;
|
|
apparentAttributesType = intersectTypes(libraryManagedAttributeType, apparentAttributesType);
|
|
}
|
|
const intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
|
|
if (!isErrorType(intrinsicAttribs)) {
|
|
apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
|
|
}
|
|
return apparentAttributesType;
|
|
}
|
|
}
|
|
function getIntersectedSignatures(signatures) {
|
|
return getStrictOptionValue(compilerOptions, "noImplicitAny") ? reduceLeft(
|
|
signatures,
|
|
(left, right) => left === right || !left ? left : compareTypeParametersIdentical(left.typeParameters, right.typeParameters) ? combineSignaturesOfIntersectionMembers(left, right) : void 0
|
|
) : void 0;
|
|
}
|
|
function combineIntersectionThisParam(left, right, mapper) {
|
|
if (!left || !right) {
|
|
return left || right;
|
|
}
|
|
const thisType = getUnionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]);
|
|
return createSymbolWithType(left, thisType);
|
|
}
|
|
function combineIntersectionParameters(left, right, mapper) {
|
|
const leftCount = getParameterCount(left);
|
|
const rightCount = getParameterCount(right);
|
|
const longest = leftCount >= rightCount ? left : right;
|
|
const shorter = longest === left ? right : left;
|
|
const longestCount = longest === left ? leftCount : rightCount;
|
|
const eitherHasEffectiveRest = hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right);
|
|
const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
|
|
const params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
|
|
for (let i = 0; i < longestCount; i++) {
|
|
let longestParamType = tryGetTypeAtPosition(longest, i);
|
|
if (longest === right) {
|
|
longestParamType = instantiateType(longestParamType, mapper);
|
|
}
|
|
let shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
|
|
if (shorter === right) {
|
|
shorterParamType = instantiateType(shorterParamType, mapper);
|
|
}
|
|
const unionParamType = getUnionType([longestParamType, shorterParamType]);
|
|
const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === longestCount - 1;
|
|
const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
|
|
const leftName = i >= leftCount ? void 0 : getParameterNameAtPosition(left, i);
|
|
const rightName = i >= rightCount ? void 0 : getParameterNameAtPosition(right, i);
|
|
const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
|
|
const paramSymbol = createSymbol(
|
|
1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
|
|
paramName || `arg${i}`
|
|
);
|
|
paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
|
|
params[i] = paramSymbol;
|
|
}
|
|
if (needsExtraRestElement) {
|
|
const restParamSymbol = createSymbol(1 /* 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) {
|
|
const typeParams = left.typeParameters || right.typeParameters;
|
|
let paramMapper;
|
|
if (left.typeParameters && right.typeParameters) {
|
|
paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
|
|
}
|
|
const declaration = left.declaration;
|
|
const params = combineIntersectionParameters(left, right, paramMapper);
|
|
const thisParam = combineIntersectionThisParam(left.thisParameter, right.thisParameter, paramMapper);
|
|
const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
|
|
const result = createSignature(
|
|
declaration,
|
|
typeParams,
|
|
thisParam,
|
|
params,
|
|
void 0,
|
|
void 0,
|
|
minArgCount,
|
|
(left.flags | right.flags) & 39 /* PropagatingFlags */
|
|
);
|
|
result.compositeKind = 2097152 /* Intersection */;
|
|
result.compositeSignatures = concatenate(left.compositeKind === 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
|
|
if (paramMapper) {
|
|
result.mapper = left.compositeKind === 2097152 /* Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper;
|
|
}
|
|
return result;
|
|
}
|
|
function getContextualCallSignature(type, node) {
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
const applicableByArity = filter(signatures, (s) => !isAritySmaller(s, node));
|
|
return applicableByArity.length === 1 ? applicableByArity[0] : getIntersectedSignatures(applicableByArity);
|
|
}
|
|
function isAritySmaller(signature, target) {
|
|
let targetParameterCount = 0;
|
|
for (; targetParameterCount < target.parameters.length; targetParameterCount++) {
|
|
const param = target.parameters[targetParameterCount];
|
|
if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) {
|
|
break;
|
|
}
|
|
}
|
|
if (target.parameters.length && parameterIsThisKeyword(target.parameters[0])) {
|
|
targetParameterCount--;
|
|
}
|
|
return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
|
|
}
|
|
function getContextualSignatureForFunctionLikeDeclaration(node) {
|
|
return isFunctionExpressionOrArrowFunction(node) || isObjectLiteralMethod(node) ? getContextualSignature(node) : void 0;
|
|
}
|
|
function getContextualSignature(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
const typeTagSignature = getSignatureOfTypeTag(node);
|
|
if (typeTagSignature) {
|
|
return typeTagSignature;
|
|
}
|
|
const type = getApparentTypeOfContextualType(node, 1 /* Signature */);
|
|
if (!type) {
|
|
return void 0;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
return getContextualCallSignature(type, node);
|
|
}
|
|
let signatureList;
|
|
const types = type.types;
|
|
for (const current of types) {
|
|
const signature = getContextualCallSignature(current, node);
|
|
if (signature) {
|
|
if (!signatureList) {
|
|
signatureList = [signature];
|
|
} else if (!compareSignaturesIdentical(signatureList[0], signature, false, true, true, compareTypesIdentical)) {
|
|
return void 0;
|
|
} else {
|
|
signatureList.push(signature);
|
|
}
|
|
}
|
|
}
|
|
if (signatureList) {
|
|
return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
|
|
}
|
|
}
|
|
function checkSpreadExpression(node, checkMode) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
|
|
}
|
|
const arrayOrIterableType = checkExpression(node.expression, checkMode);
|
|
return checkIteratedTypeOrElementType(33 /* Spread */, arrayOrIterableType, undefinedType, node.expression);
|
|
}
|
|
function checkSyntheticExpression(node) {
|
|
return node.isSpread ? getIndexedAccessType(node.type, numberType) : node.type;
|
|
}
|
|
function hasDefaultValue(node) {
|
|
return node.kind === 205 /* BindingElement */ && !!node.initializer || node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 63 /* EqualsToken */;
|
|
}
|
|
function checkArrayLiteral(node, checkMode, forceTuple) {
|
|
const elements = node.elements;
|
|
const elementCount = elements.length;
|
|
const elementTypes = [];
|
|
const elementFlags = [];
|
|
const contextualType = getApparentTypeOfContextualType(node, void 0);
|
|
const inDestructuringPattern = isAssignmentTarget(node);
|
|
const inConstContext = isConstContext(node);
|
|
let hasOmittedExpression = false;
|
|
for (let i = 0; i < elementCount; i++) {
|
|
const e = elements[i];
|
|
if (e.kind === 227 /* SpreadElement */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
|
|
}
|
|
const spreadType = checkExpression(e.expression, checkMode, forceTuple);
|
|
if (isArrayLikeType(spreadType)) {
|
|
elementTypes.push(spreadType);
|
|
elementFlags.push(8 /* Variadic */);
|
|
} else if (inDestructuringPattern) {
|
|
const restElementType = getIndexTypeOfType(spreadType, numberType) || getIteratedTypeOrElementType(65 /* Destructuring */, spreadType, undefinedType, void 0, false) || unknownType;
|
|
elementTypes.push(restElementType);
|
|
elementFlags.push(4 /* Rest */);
|
|
} else {
|
|
elementTypes.push(checkIteratedTypeOrElementType(33 /* Spread */, spreadType, undefinedType, e.expression));
|
|
elementFlags.push(4 /* Rest */);
|
|
}
|
|
} else if (exactOptionalPropertyTypes && e.kind === 229 /* OmittedExpression */) {
|
|
hasOmittedExpression = true;
|
|
elementTypes.push(missingType);
|
|
elementFlags.push(2 /* Optional */);
|
|
} else {
|
|
const elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
|
|
const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
|
|
elementTypes.push(addOptionality(type, true, hasOmittedExpression));
|
|
elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
|
|
if (contextualType && someType(contextualType, isTupleLikeType) && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
Debug.assert(inferenceContext);
|
|
addIntraExpressionInferenceSite(inferenceContext, e, type);
|
|
}
|
|
}
|
|
}
|
|
if (inDestructuringPattern) {
|
|
return createTupleType(elementTypes, elementFlags);
|
|
}
|
|
if (forceTuple || inConstContext || contextualType && someType(contextualType, isTupleLikeType)) {
|
|
return createArrayLiteralType(createTupleType(elementTypes, elementFlags, inConstContext));
|
|
}
|
|
return createArrayLiteralType(createArrayType(elementTypes.length ? getUnionType(sameMap(elementTypes, (t, i) => elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t), 2 /* Subtype */) : strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
|
|
}
|
|
function createArrayLiteralType(type) {
|
|
if (!(getObjectFlags(type) & 4 /* Reference */)) {
|
|
return type;
|
|
}
|
|
let literalType = type.literalType;
|
|
if (!literalType) {
|
|
literalType = type.literalType = cloneTypeReference(type);
|
|
literalType.objectFlags |= 16384 /* ArrayLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return literalType;
|
|
}
|
|
function isNumericName(name) {
|
|
switch (name.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
return isNumericComputedName(name);
|
|
case 79 /* Identifier */:
|
|
return isNumericLiteralName(name.escapedText);
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return isNumericLiteralName(name.text);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isNumericComputedName(name) {
|
|
return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* NumberLike */);
|
|
}
|
|
function checkComputedPropertyName(node) {
|
|
const links = getNodeLinks(node.expression);
|
|
if (!links.resolvedType) {
|
|
if ((isTypeLiteralNode(node.parent.parent) || isClassLike(node.parent.parent) || isInterfaceDeclaration(node.parent.parent)) && isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101 /* InKeyword */ && node.parent.kind !== 174 /* GetAccessor */ && node.parent.kind !== 175 /* SetAccessor */) {
|
|
return links.resolvedType = errorType;
|
|
}
|
|
links.resolvedType = checkExpression(node.expression);
|
|
if (isPropertyDeclaration(node.parent) && !hasStaticModifier(node.parent) && isClassExpression(node.parent.parent)) {
|
|
const container = getEnclosingBlockScopeContainer(node.parent.parent);
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(container);
|
|
if (enclosingIterationStatement) {
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
getNodeLinks(node).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
getNodeLinks(node.parent.parent).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
}
|
|
}
|
|
if (links.resolvedType.flags & 98304 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
|
|
error(node, Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isSymbolWithNumericName(symbol) {
|
|
var _a2;
|
|
const firstDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
|
|
return isNumericLiteralName(symbol.escapedName) || firstDecl && isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name);
|
|
}
|
|
function isSymbolWithSymbolName(symbol) {
|
|
var _a2;
|
|
const firstDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
|
|
return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* ESSymbol */);
|
|
}
|
|
function getObjectLiteralIndexInfo(node, offset, properties, keyType) {
|
|
const propTypes = [];
|
|
for (let i = offset; i < properties.length; i++) {
|
|
const prop = properties[i];
|
|
if (keyType === stringType && !isSymbolWithSymbolName(prop) || keyType === numberType && isSymbolWithNumericName(prop) || keyType === esSymbolType && isSymbolWithSymbolName(prop)) {
|
|
propTypes.push(getTypeOfSymbol(properties[i]));
|
|
}
|
|
}
|
|
const unionType = propTypes.length ? getUnionType(propTypes, 2 /* Subtype */) : undefinedType;
|
|
return createIndexInfo(keyType, unionType, isConstContext(node));
|
|
}
|
|
function getImmediateAliasedSymbol(symbol) {
|
|
Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.immediateTarget) {
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
links.immediateTarget = getTargetOfAliasDeclaration(node, true);
|
|
}
|
|
return links.immediateTarget;
|
|
}
|
|
function checkObjectLiteral(node, checkMode) {
|
|
const inDestructuringPattern = isAssignmentTarget(node);
|
|
checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
|
|
const allPropertiesTable = strictNullChecks ? createSymbolTable() : void 0;
|
|
let propertiesTable = createSymbolTable();
|
|
let propertiesArray = [];
|
|
let spread = emptyObjectType;
|
|
const contextualType = getApparentTypeOfContextualType(node, void 0);
|
|
const contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === 203 /* ObjectBindingPattern */ || contextualType.pattern.kind === 207 /* ObjectLiteralExpression */);
|
|
const inConstContext = isConstContext(node);
|
|
const checkFlags = inConstContext ? 8 /* Readonly */ : 0;
|
|
const isInJavascript = isInJSFile(node) && !isInJsonFile(node);
|
|
const enumTag = getJSDocEnumTag(node);
|
|
const isJSObjectLiteral = !contextualType && isInJavascript && !enumTag;
|
|
let objectFlags = freshObjectLiteralFlag;
|
|
let patternWithComputedProperties = false;
|
|
let hasComputedStringProperty = false;
|
|
let hasComputedNumberProperty = false;
|
|
let hasComputedSymbolProperty = false;
|
|
for (const elem of node.properties) {
|
|
if (elem.name && isComputedPropertyName(elem.name)) {
|
|
checkComputedPropertyName(elem.name);
|
|
}
|
|
}
|
|
let offset = 0;
|
|
for (const memberDecl of node.properties) {
|
|
let member = getSymbolOfNode(memberDecl);
|
|
const computedNameType = memberDecl.name && memberDecl.name.kind === 164 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
|
|
if (memberDecl.kind === 299 /* PropertyAssignment */ || memberDecl.kind === 300 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
|
|
let type = memberDecl.kind === 299 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : memberDecl.kind === 300 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode);
|
|
if (isInJavascript) {
|
|
const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
|
|
if (jsDocType) {
|
|
checkTypeAssignableTo(type, jsDocType, memberDecl);
|
|
type = jsDocType;
|
|
} else if (enumTag && enumTag.typeExpression) {
|
|
checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
|
|
}
|
|
}
|
|
objectFlags |= getObjectFlags(type) & 458752 /* PropagatingFlags */;
|
|
const nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : void 0;
|
|
const prop = nameType ? createSymbol(4 /* Property */ | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096 /* Late */) : createSymbol(4 /* Property */ | member.flags, member.escapedName, checkFlags);
|
|
if (nameType) {
|
|
prop.nameType = nameType;
|
|
}
|
|
if (inDestructuringPattern) {
|
|
const isOptional = memberDecl.kind === 299 /* PropertyAssignment */ && hasDefaultValue(memberDecl.initializer) || memberDecl.kind === 300 /* ShorthandPropertyAssignment */ && memberDecl.objectAssignmentInitializer;
|
|
if (isOptional) {
|
|
prop.flags |= 16777216 /* Optional */;
|
|
}
|
|
} else if (contextualTypeHasPattern && !(getObjectFlags(contextualType) & 512 /* ObjectLiteralPatternWithComputedProperties */)) {
|
|
const impliedProp = getPropertyOfType(contextualType, member.escapedName);
|
|
if (impliedProp) {
|
|
prop.flags |= impliedProp.flags & 16777216 /* Optional */;
|
|
} else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, stringType)) {
|
|
error(
|
|
memberDecl.name,
|
|
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 ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
|
|
if (contextualType && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 299 /* PropertyAssignment */ || memberDecl.kind === 171 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
Debug.assert(inferenceContext);
|
|
const inferenceNode = memberDecl.kind === 299 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
|
|
addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
|
|
}
|
|
} else if (memberDecl.kind === 301 /* SpreadAssignment */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(memberDecl, 2 /* Assign */);
|
|
}
|
|
if (propertiesArray.length > 0) {
|
|
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
|
|
propertiesArray = [];
|
|
propertiesTable = createSymbolTable();
|
|
hasComputedStringProperty = false;
|
|
hasComputedNumberProperty = false;
|
|
hasComputedSymbolProperty = false;
|
|
}
|
|
const type = getReducedType(checkExpression(memberDecl.expression));
|
|
if (isValidSpreadType(type)) {
|
|
const 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, Diagnostics.Spread_types_may_only_be_created_from_object_types);
|
|
spread = errorType;
|
|
}
|
|
continue;
|
|
} else {
|
|
Debug.assert(memberDecl.kind === 174 /* GetAccessor */ || memberDecl.kind === 175 /* SetAccessor */);
|
|
checkNodeDeferred(memberDecl);
|
|
}
|
|
if (computedNameType && !(computedNameType.flags & 8576 /* 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 (contextualTypeHasPattern) {
|
|
const rootPatternParent = findAncestor(
|
|
contextualType.pattern.parent,
|
|
(n) => n.kind === 257 /* VariableDeclaration */ || n.kind === 223 /* BinaryExpression */ || n.kind === 166 /* Parameter */
|
|
);
|
|
const spreadOrOutsideRootObject = findAncestor(
|
|
node,
|
|
(n) => n === rootPatternParent || n.kind === 301 /* SpreadAssignment */
|
|
);
|
|
if (spreadOrOutsideRootObject.kind !== 301 /* SpreadAssignment */) {
|
|
for (const prop of getPropertiesOfType(contextualType)) {
|
|
if (!propertiesTable.get(prop.escapedName) && !getPropertyOfType(spread, prop.escapedName)) {
|
|
if (!(prop.flags & 16777216 /* Optional */)) {
|
|
error(
|
|
prop.valueDeclaration || prop.bindingElement,
|
|
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 = createSymbolTable();
|
|
hasComputedStringProperty = false;
|
|
hasComputedNumberProperty = false;
|
|
}
|
|
return mapType(spread, (t) => t === emptyObjectType ? createObjectLiteralType() : t);
|
|
}
|
|
return createObjectLiteralType();
|
|
function createObjectLiteralType() {
|
|
const 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));
|
|
const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, indexInfos);
|
|
result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
if (isJSObjectLiteral) {
|
|
result.objectFlags |= 4096 /* JSLiteral */;
|
|
}
|
|
if (patternWithComputedProperties) {
|
|
result.objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
|
|
}
|
|
if (inDestructuringPattern) {
|
|
result.pattern = node;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function isValidSpreadType(type) {
|
|
const t = removeDefinitelyFalsyTypes(mapType(type, getBaseConstraintOrType));
|
|
return !!(t.flags & (1 /* Any */ | 67108864 /* NonPrimitive */ | 524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) || t.flags & 3145728 /* UnionOrIntersection */ && every(t.types, isValidSpreadType));
|
|
}
|
|
function checkJsxSelfClosingElementDeferred(node) {
|
|
checkJsxOpeningLikeElementOrOpeningFragment(node);
|
|
}
|
|
function checkJsxSelfClosingElement(node, _checkMode) {
|
|
checkNodeDeferred(node);
|
|
return getJsxElementTypeAt(node) || anyType;
|
|
}
|
|
function checkJsxElementDeferred(node) {
|
|
checkJsxOpeningLikeElementOrOpeningFragment(node.openingElement);
|
|
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);
|
|
const nodeSourceFile = getSourceFileOfNode(node);
|
|
if (getJSXTransformEnabled(compilerOptions) && (compilerOptions.jsxFactory || nodeSourceFile.pragmas.has("jsx")) && !compilerOptions.jsxFragmentFactory && !nodeSourceFile.pragmas.has("jsxfrag")) {
|
|
error(node, compilerOptions.jsxFactory ? Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option : Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments);
|
|
}
|
|
checkJsxChildren(node);
|
|
return getJsxElementTypeAt(node) || anyType;
|
|
}
|
|
function isHyphenatedJsxName(name) {
|
|
return stringContains(name, "-");
|
|
}
|
|
function isJsxIntrinsicIdentifier(tagName) {
|
|
return tagName.kind === 79 /* Identifier */ && isIntrinsicJsxName(tagName.escapedText);
|
|
}
|
|
function checkJsxAttribute(node, checkMode) {
|
|
return node.initializer ? checkExpressionForMutableLocation(node.initializer, checkMode) : trueType;
|
|
}
|
|
function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) {
|
|
const attributes = openingLikeElement.attributes;
|
|
const attributesType = getContextualType(attributes, 0 /* None */);
|
|
const allAttributesTable = strictNullChecks ? createSymbolTable() : void 0;
|
|
let attributesTable = createSymbolTable();
|
|
let spread = emptyJsxObjectType;
|
|
let hasSpreadAnyType = false;
|
|
let typeToIntersect;
|
|
let explicitlySpecifyChildrenAttribute = false;
|
|
let objectFlags = 2048 /* JsxAttributes */;
|
|
const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
|
|
for (const attributeDecl of attributes.properties) {
|
|
const member = attributeDecl.symbol;
|
|
if (isJsxAttribute(attributeDecl)) {
|
|
const exprType = checkJsxAttribute(attributeDecl, checkMode);
|
|
objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
|
|
const attributeSymbol = createSymbol(4 /* 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 ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
|
|
if (attributeDecl.name.escapedText === jsxChildrenPropertyName) {
|
|
explicitlySpecifyChildrenAttribute = true;
|
|
}
|
|
if (attributesType) {
|
|
const prop = getPropertyOfType(attributesType, member.escapedName);
|
|
if (prop && prop.declarations && isDeprecatedSymbol(prop)) {
|
|
addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
|
|
}
|
|
}
|
|
} else {
|
|
Debug.assert(attributeDecl.kind === 290 /* JsxSpreadAttribute */);
|
|
if (attributesTable.size > 0) {
|
|
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
|
|
attributesTable = createSymbolTable();
|
|
}
|
|
const exprType = getReducedType(checkExpressionCached(attributeDecl.expression, checkMode));
|
|
if (isTypeAny(exprType)) {
|
|
hasSpreadAnyType = true;
|
|
}
|
|
if (isValidSpreadType(exprType)) {
|
|
spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, false);
|
|
if (allAttributesTable) {
|
|
checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
|
|
}
|
|
} else {
|
|
error(attributeDecl.expression, 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, false);
|
|
}
|
|
}
|
|
const parent = openingLikeElement.parent.kind === 281 /* JsxElement */ ? openingLikeElement.parent : void 0;
|
|
if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) {
|
|
const childrenTypes = checkJsxChildren(parent, checkMode);
|
|
if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
|
|
if (explicitlySpecifyChildrenAttribute) {
|
|
error(attributes, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName));
|
|
}
|
|
const contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, void 0);
|
|
const childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
|
|
const childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
|
|
childrenPropSymbol.type = childrenTypes.length === 1 ? childrenTypes[0] : childrenContextualType && someType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) : createArrayType(getUnionType(childrenTypes));
|
|
childrenPropSymbol.valueDeclaration = factory.createPropertySignature(void 0, unescapeLeadingUnderscores(jsxChildrenPropertyName), void 0, void 0);
|
|
setParent(childrenPropSymbol.valueDeclaration, attributes);
|
|
childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol;
|
|
const childPropMap = createSymbolTable();
|
|
childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
|
|
spread = getSpreadType(
|
|
spread,
|
|
createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, emptyArray),
|
|
attributes.symbol,
|
|
objectFlags,
|
|
false
|
|
);
|
|
}
|
|
}
|
|
if (hasSpreadAnyType) {
|
|
return anyType;
|
|
}
|
|
if (typeToIntersect && spread !== emptyJsxObjectType) {
|
|
return getIntersectionType([typeToIntersect, spread]);
|
|
}
|
|
return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread);
|
|
function createJsxAttributesType() {
|
|
objectFlags |= freshObjectLiteralFlag;
|
|
const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, emptyArray);
|
|
result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
return result;
|
|
}
|
|
}
|
|
function checkJsxChildren(node, checkMode) {
|
|
const childrenTypes = [];
|
|
for (const child of node.children) {
|
|
if (child.kind === 11 /* JsxText */) {
|
|
if (!child.containsOnlyTriviaWhiteSpaces) {
|
|
childrenTypes.push(stringType);
|
|
}
|
|
} else if (child.kind === 291 /* JsxExpression */ && !child.expression) {
|
|
continue;
|
|
} else {
|
|
childrenTypes.push(checkExpressionForMutableLocation(child, checkMode));
|
|
}
|
|
}
|
|
return childrenTypes;
|
|
}
|
|
function checkSpreadPropOverrides(type, props, spread) {
|
|
for (const right of getPropertiesOfType(type)) {
|
|
if (!(right.flags & 16777216 /* Optional */)) {
|
|
const left = props.get(right.escapedName);
|
|
if (left) {
|
|
const diagnostic = error(left.valueDeclaration, Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, unescapeLeadingUnderscores(left.escapedName));
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(spread, Diagnostics.This_spread_always_overwrites_this_property));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkJsxAttributes(node, checkMode) {
|
|
return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode);
|
|
}
|
|
function getJsxType(name, location) {
|
|
const namespace = getJsxNamespaceAt(location);
|
|
const exports = namespace && getExportsOfSymbol(namespace);
|
|
const typeSymbol = exports && getSymbol(exports, name, 788968 /* Type */);
|
|
return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType;
|
|
}
|
|
function getIntrinsicTagSymbol(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedSymbol) {
|
|
const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
|
|
if (!isErrorType(intrinsicElementsType)) {
|
|
if (!isIdentifier(node.tagName))
|
|
return Debug.fail();
|
|
const intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText);
|
|
if (intrinsicProp) {
|
|
links.jsxFlags |= 1 /* IntrinsicNamedElement */;
|
|
return links.resolvedSymbol = intrinsicProp;
|
|
}
|
|
const indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType);
|
|
if (indexSignatureType) {
|
|
links.jsxFlags |= 2 /* IntrinsicIndexedElement */;
|
|
return links.resolvedSymbol = intrinsicElementsType.symbol;
|
|
}
|
|
error(node, Diagnostics.Property_0_does_not_exist_on_type_1, idText(node.tagName), "JSX." + JsxNames.IntrinsicElements);
|
|
return links.resolvedSymbol = unknownSymbol;
|
|
} else {
|
|
if (noImplicitAny) {
|
|
error(node, Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, unescapeLeadingUnderscores(JsxNames.IntrinsicElements));
|
|
}
|
|
return links.resolvedSymbol = unknownSymbol;
|
|
}
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function getJsxNamespaceContainerForImplicitImport(location) {
|
|
const file = location && getSourceFileOfNode(location);
|
|
const links = file && getNodeLinks(file);
|
|
if (links && links.jsxImplicitImportContainer === false) {
|
|
return void 0;
|
|
}
|
|
if (links && links.jsxImplicitImportContainer) {
|
|
return links.jsxImplicitImportContainer;
|
|
}
|
|
const runtimeImportSpecifier = getJSXRuntimeImport(getJSXImplicitImportBase(compilerOptions, file), compilerOptions);
|
|
if (!runtimeImportSpecifier) {
|
|
return void 0;
|
|
}
|
|
const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */;
|
|
const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
|
|
const mod = resolveExternalModule(location, runtimeImportSpecifier, errorMessage, location);
|
|
const result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : void 0;
|
|
if (links) {
|
|
links.jsxImplicitImportContainer = result || false;
|
|
}
|
|
return result;
|
|
}
|
|
function getJsxNamespaceAt(location) {
|
|
const links = location && getNodeLinks(location);
|
|
if (links && links.jsxNamespace) {
|
|
return links.jsxNamespace;
|
|
}
|
|
if (!links || links.jsxNamespace !== false) {
|
|
let resolvedNamespace = getJsxNamespaceContainerForImplicitImport(location);
|
|
if (!resolvedNamespace || resolvedNamespace === unknownSymbol) {
|
|
const namespaceName = getJsxNamespace(location);
|
|
resolvedNamespace = resolveName(location, namespaceName, 1920 /* Namespace */, void 0, namespaceName, false);
|
|
}
|
|
if (resolvedNamespace) {
|
|
const candidate = resolveSymbol(getSymbol(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920 /* Namespace */));
|
|
if (candidate && candidate !== unknownSymbol) {
|
|
if (links) {
|
|
links.jsxNamespace = candidate;
|
|
}
|
|
return candidate;
|
|
}
|
|
}
|
|
if (links) {
|
|
links.jsxNamespace = false;
|
|
}
|
|
}
|
|
const s = resolveSymbol(getGlobalSymbol(JsxNames.JSX, 1920 /* Namespace */, void 0));
|
|
if (s === unknownSymbol) {
|
|
return void 0;
|
|
}
|
|
return s;
|
|
}
|
|
function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) {
|
|
const jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol(jsxNamespace.exports, nameOfAttribPropContainer, 788968 /* Type */);
|
|
const jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym);
|
|
const propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType);
|
|
if (propertiesOfJsxElementAttribPropInterface) {
|
|
if (propertiesOfJsxElementAttribPropInterface.length === 0) {
|
|
return "";
|
|
} else if (propertiesOfJsxElementAttribPropInterface.length === 1) {
|
|
return propertiesOfJsxElementAttribPropInterface[0].escapedName;
|
|
} else if (propertiesOfJsxElementAttribPropInterface.length > 1 && jsxElementAttribPropInterfaceSym.declarations) {
|
|
error(jsxElementAttribPropInterfaceSym.declarations[0], Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, unescapeLeadingUnderscores(nameOfAttribPropContainer));
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getJsxLibraryManagedAttributes(jsxNamespace) {
|
|
return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* 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 /* String */) {
|
|
return [anySignature];
|
|
} else if (elementType.flags & 128 /* StringLiteral */) {
|
|
const intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller);
|
|
if (!intrinsicType) {
|
|
error(caller, Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements);
|
|
return emptyArray;
|
|
} else {
|
|
const fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType);
|
|
return [fakeSignature];
|
|
}
|
|
}
|
|
const apparentElemType = getApparentType(elementType);
|
|
let signatures = getSignaturesOfType(apparentElemType, 1 /* Construct */);
|
|
if (signatures.length === 0) {
|
|
signatures = getSignaturesOfType(apparentElemType, 0 /* Call */);
|
|
}
|
|
if (signatures.length === 0 && apparentElemType.flags & 1048576 /* Union */) {
|
|
signatures = getUnionSignatures(map(apparentElemType.types, (t) => getUninstantiatedJsxSignaturesOfType(t, caller)));
|
|
}
|
|
return signatures;
|
|
}
|
|
function getIntrinsicAttributesTypeFromStringLiteralType(type, location) {
|
|
const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location);
|
|
if (!isErrorType(intrinsicElementsType)) {
|
|
const stringLiteralTypeName = type.value;
|
|
const intrinsicProp = getPropertyOfType(intrinsicElementsType, escapeLeadingUnderscores(stringLiteralTypeName));
|
|
if (intrinsicProp) {
|
|
return getTypeOfSymbol(intrinsicProp);
|
|
}
|
|
const indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType);
|
|
if (indexSignatureType) {
|
|
return indexSignatureType;
|
|
}
|
|
return void 0;
|
|
}
|
|
return anyType;
|
|
}
|
|
function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) {
|
|
if (refKind === 1 /* Function */) {
|
|
const sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
|
|
if (sfcReturnConstraint) {
|
|
checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
} else if (refKind === 0 /* Component */) {
|
|
const classConstraint = getJsxElementClassTypeAt(openingLikeElement);
|
|
if (classConstraint) {
|
|
checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
} else {
|
|
const sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
|
|
const classConstraint = getJsxElementClassTypeAt(openingLikeElement);
|
|
if (!sfcReturnConstraint || !classConstraint) {
|
|
return;
|
|
}
|
|
const combined = getUnionType([sfcReturnConstraint, classConstraint]);
|
|
checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
function generateInitialErrorChain() {
|
|
const componentName = getTextOfNode(openingLikeElement.tagName);
|
|
return chainDiagnosticMessages(void 0, Diagnostics._0_cannot_be_used_as_a_JSX_component, componentName);
|
|
}
|
|
}
|
|
function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) {
|
|
Debug.assert(isJsxIntrinsicIdentifier(node.tagName));
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedJsxElementAttributesType) {
|
|
const symbol = getIntrinsicTagSymbol(node);
|
|
if (links.jsxFlags & 1 /* IntrinsicNamedElement */) {
|
|
return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol) || errorType;
|
|
} else if (links.jsxFlags & 2 /* IntrinsicIndexedElement */) {
|
|
return links.resolvedJsxElementAttributesType = getIndexTypeOfType(getJsxType(JsxNames.IntrinsicElements, node), stringType) || errorType;
|
|
} else {
|
|
return links.resolvedJsxElementAttributesType = errorType;
|
|
}
|
|
}
|
|
return links.resolvedJsxElementAttributesType;
|
|
}
|
|
function getJsxElementClassTypeAt(location) {
|
|
const type = getJsxType(JsxNames.ElementClass, location);
|
|
if (isErrorType(type))
|
|
return void 0;
|
|
return type;
|
|
}
|
|
function getJsxElementTypeAt(location) {
|
|
return getJsxType(JsxNames.Element, location);
|
|
}
|
|
function getJsxStatelessElementTypeAt(location) {
|
|
const jsxElementType = getJsxElementTypeAt(location);
|
|
if (jsxElementType) {
|
|
return getUnionType([jsxElementType, nullType]);
|
|
}
|
|
}
|
|
function getJsxIntrinsicTagNamesAt(location) {
|
|
const intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
|
|
return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
|
|
}
|
|
function checkJsxPreconditions(errorNode) {
|
|
if ((compilerOptions.jsx || 0 /* None */) === 0 /* None */) {
|
|
error(errorNode, Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
|
|
}
|
|
if (getJsxElementTypeAt(errorNode) === void 0) {
|
|
if (noImplicitAny) {
|
|
error(errorNode, Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist);
|
|
}
|
|
}
|
|
}
|
|
function checkJsxOpeningLikeElementOrOpeningFragment(node) {
|
|
const isNodeOpeningLikeElement = isJsxOpeningLikeElement(node);
|
|
if (isNodeOpeningLikeElement) {
|
|
checkGrammarJsxElement(node);
|
|
}
|
|
checkJsxPreconditions(node);
|
|
if (!getJsxNamespaceContainerForImplicitImport(node)) {
|
|
const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
|
|
const jsxFactoryNamespace = getJsxNamespace(node);
|
|
const jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
|
|
let jsxFactorySym;
|
|
if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
|
|
jsxFactorySym = resolveName(jsxFactoryLocation, jsxFactoryNamespace, 111551 /* Value */, jsxFactoryRefErr, jsxFactoryNamespace, true);
|
|
}
|
|
if (jsxFactorySym) {
|
|
jsxFactorySym.isReferenced = 67108863 /* All */;
|
|
if (jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
|
|
markAliasSymbolAsReferenced(jsxFactorySym);
|
|
}
|
|
}
|
|
if (isJsxOpeningFragment(node)) {
|
|
const file = getSourceFileOfNode(node);
|
|
const localJsxNamespace = getLocalJsxNamespace(file);
|
|
if (localJsxNamespace) {
|
|
resolveName(jsxFactoryLocation, localJsxNamespace, 111551 /* Value */, jsxFactoryRefErr, localJsxNamespace, true);
|
|
}
|
|
}
|
|
}
|
|
if (isNodeOpeningLikeElement) {
|
|
const jsxOpeningLikeNode = node;
|
|
const sig = getResolvedSignature(jsxOpeningLikeNode);
|
|
checkDeprecatedSignature(sig, node);
|
|
checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
|
|
}
|
|
}
|
|
function isKnownProperty(targetType, name, isComparingJsxAttributes) {
|
|
if (targetType.flags & 524288 /* Object */) {
|
|
if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
|
|
return true;
|
|
}
|
|
} else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
|
|
for (const t of targetType.types) {
|
|
if (isKnownProperty(t, name, isComparingJsxAttributes)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isExcessPropertyCheckTarget(type) {
|
|
return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
|
|
}
|
|
function checkJsxExpression(node, checkMode) {
|
|
checkGrammarJsxExpression(node);
|
|
if (node.expression) {
|
|
const type = checkExpression(node.expression, checkMode);
|
|
if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) {
|
|
error(node, Diagnostics.JSX_spread_child_must_be_an_array_type);
|
|
}
|
|
return type;
|
|
} else {
|
|
return errorType;
|
|
}
|
|
}
|
|
function getDeclarationNodeFlagsFromSymbol(s) {
|
|
return s.valueDeclaration ? getCombinedNodeFlags(s.valueDeclaration) : 0;
|
|
}
|
|
function isPrototypeProperty(symbol) {
|
|
if (symbol.flags & 8192 /* Method */ || getCheckFlags(symbol) & 4 /* SyntheticMethod */) {
|
|
return true;
|
|
}
|
|
if (isInJSFile(symbol.valueDeclaration)) {
|
|
const parent = symbol.valueDeclaration.parent;
|
|
return parent && isBinaryExpression(parent) && getAssignmentDeclarationKind(parent) === 3 /* PrototypeProperty */;
|
|
}
|
|
}
|
|
function checkPropertyAccessibility(node, isSuper, writing, type, prop, reportError = true) {
|
|
const errorNode = !reportError ? void 0 : node.kind === 163 /* QualifiedName */ ? node.right : node.kind === 202 /* ImportType */ ? node : node.kind === 205 /* BindingElement */ && node.propertyName ? node.propertyName : node.name;
|
|
return checkPropertyAccessibilityAtLocation(node, isSuper, writing, type, prop, errorNode);
|
|
}
|
|
function checkPropertyAccessibilityAtLocation(location, isSuper, writing, containingType, prop, errorNode) {
|
|
const flags = getDeclarationModifierFlagsFromSymbol(prop, writing);
|
|
if (isSuper) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (symbolHasNonMethodDeclaration(prop)) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 256 /* Abstract */) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop))
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 256 /* Abstract */ && symbolHasNonMethodDeclaration(prop) && (isThisProperty(location) || isThisInitializedObjectBindingExpression(location) || isObjectBindingPattern(location.parent) && isThisInitializedDeclaration(location.parent.parent))) {
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
|
|
if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(location)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor,
|
|
symbolToString(prop),
|
|
getTextOfIdentifierOrLiteral(declaringClassDeclaration.name)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (!(flags & 24 /* NonPublicAccessibilityModifier */)) {
|
|
return true;
|
|
}
|
|
if (flags & 8 /* Private */) {
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
|
|
if (!isNodeWithinClass(location, declaringClassDeclaration)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Property_0_is_private_and_only_accessible_within_class_1,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop))
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (isSuper) {
|
|
return true;
|
|
}
|
|
let enclosingClass = forEachEnclosingClass(location, (enclosingDeclaration) => {
|
|
const enclosingClass2 = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
|
|
return isClassDerivedFromDeclaringClasses(enclosingClass2, prop, writing);
|
|
});
|
|
if (!enclosingClass) {
|
|
enclosingClass = getEnclosingClassFromThisParameter(location);
|
|
enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
|
|
if (flags & 32 /* Static */ || !enclosingClass) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop) || containingType)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 32 /* Static */) {
|
|
return true;
|
|
}
|
|
if (containingType.flags & 262144 /* TypeParameter */) {
|
|
containingType = containingType.isThisType ? getConstraintOfTypeParameter(containingType) : getBaseConstraintOfType(containingType);
|
|
}
|
|
if (!containingType || !hasBaseType(containingType, enclosingClass)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
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) {
|
|
const thisParameter = getThisParameterFromNodeContext(node);
|
|
let thisType = (thisParameter == null ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
|
|
if (thisType && thisType.flags & 262144 /* TypeParameter */) {
|
|
thisType = getConstraintOfTypeParameter(thisType);
|
|
}
|
|
if (thisType && getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
|
|
return getTargetType(thisType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getThisParameterFromNodeContext(node) {
|
|
const thisContainer = getThisContainer(node, false);
|
|
return thisContainer && isFunctionLike(thisContainer) ? getThisParameter(thisContainer) : void 0;
|
|
}
|
|
function symbolHasNonMethodDeclaration(symbol) {
|
|
return !!forEachProperty(symbol, (prop) => !(prop.flags & 8192 /* Method */));
|
|
}
|
|
function checkNonNullExpression(node) {
|
|
return checkNonNullType(checkExpression(node), node);
|
|
}
|
|
function isNullableType(type) {
|
|
return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
|
|
}
|
|
function getNonNullableTypeIfNeeded(type) {
|
|
return isNullableType(type) ? getNonNullableType(type) : type;
|
|
}
|
|
function reportObjectPossiblyNullOrUndefinedError(node, facts) {
|
|
const nodeText = isEntityNameExpression(node) ? entityNameToString(node) : void 0;
|
|
if (node.kind === 104 /* NullKeyword */) {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, "null");
|
|
return;
|
|
}
|
|
if (nodeText !== void 0 && nodeText.length < 100) {
|
|
if (isIdentifier(node) && nodeText === "undefined") {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, "undefined");
|
|
return;
|
|
}
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics._0_is_possibly_null_or_undefined : Diagnostics._0_is_possibly_undefined : Diagnostics._0_is_possibly_null,
|
|
nodeText
|
|
);
|
|
} else {
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics.Object_is_possibly_null_or_undefined : Diagnostics.Object_is_possibly_undefined : Diagnostics.Object_is_possibly_null
|
|
);
|
|
}
|
|
}
|
|
function reportCannotInvokePossiblyNullOrUndefinedError(node, facts) {
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined : Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined : Diagnostics.Cannot_invoke_an_object_which_is_possibly_null
|
|
);
|
|
}
|
|
function checkNonNullTypeWithReporter(type, node, reportError) {
|
|
if (strictNullChecks && type.flags & 2 /* Unknown */) {
|
|
if (isEntityNameExpression(node)) {
|
|
const nodeText = entityNameToString(node);
|
|
if (nodeText.length < 100) {
|
|
error(node, Diagnostics._0_is_of_type_unknown, nodeText);
|
|
return errorType;
|
|
}
|
|
}
|
|
error(node, Diagnostics.Object_is_of_type_unknown);
|
|
return errorType;
|
|
}
|
|
const facts = getTypeFacts(type);
|
|
if (facts & 50331648 /* IsUndefinedOrNull */) {
|
|
reportError(node, facts);
|
|
const t = getNonNullableType(type);
|
|
return t.flags & (98304 /* Nullable */ | 131072 /* Never */) ? errorType : t;
|
|
}
|
|
return type;
|
|
}
|
|
function checkNonNullType(type, node) {
|
|
return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError);
|
|
}
|
|
function checkNonNullNonVoidType(type, node) {
|
|
const nonNullType = checkNonNullType(type, node);
|
|
if (nonNullType.flags & 16384 /* Void */) {
|
|
if (isEntityNameExpression(node)) {
|
|
const nodeText = entityNameToString(node);
|
|
if (isIdentifier(node) && nodeText === "undefined") {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, nodeText);
|
|
return nonNullType;
|
|
}
|
|
if (nodeText.length < 100) {
|
|
error(node, Diagnostics._0_is_possibly_undefined, nodeText);
|
|
return nonNullType;
|
|
}
|
|
}
|
|
error(node, Diagnostics.Object_is_possibly_undefined);
|
|
}
|
|
return nonNullType;
|
|
}
|
|
function checkPropertyAccessExpression(node, checkMode) {
|
|
return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode);
|
|
}
|
|
function checkPropertyAccessChain(node, checkMode) {
|
|
const leftType = checkExpression(node.expression);
|
|
const 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) {
|
|
const leftType = isPartOfTypeQuery(node) && 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 /* ParenthesizedExpression */) {
|
|
node = node.parent;
|
|
}
|
|
return isCallOrNewExpression(node.parent) && node.parent.expression === node;
|
|
}
|
|
function lookupSymbolForPrivateIdentifierDeclaration(propName, location) {
|
|
for (let containingClass = getContainingClass(location); !!containingClass; containingClass = getContainingClass(containingClass)) {
|
|
const { symbol } = containingClass;
|
|
const name = getSymbolNameForPrivateIdentifier(symbol, propName);
|
|
const prop = symbol.members && symbol.members.get(name) || symbol.exports && symbol.exports.get(name);
|
|
if (prop) {
|
|
return prop;
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarPrivateIdentifierExpression(privId) {
|
|
if (!getContainingClass(privId)) {
|
|
return grammarErrorOnNode(privId, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
if (!isForInStatement(privId.parent)) {
|
|
if (!isExpressionNode(privId)) {
|
|
return grammarErrorOnNode(privId, 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);
|
|
}
|
|
const isInOperation = isBinaryExpression(privId.parent) && privId.parent.operatorToken.kind === 101 /* InKeyword */;
|
|
if (!getSymbolForPrivateIdentifierExpression(privId) && !isInOperation) {
|
|
return grammarErrorOnNode(privId, Diagnostics.Cannot_find_name_0, idText(privId));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkPrivateIdentifierExpression(privId) {
|
|
checkGrammarPrivateIdentifierExpression(privId);
|
|
const symbol = getSymbolForPrivateIdentifierExpression(privId);
|
|
if (symbol) {
|
|
markPropertyAsReferenced(symbol, void 0, false);
|
|
}
|
|
return anyType;
|
|
}
|
|
function getSymbolForPrivateIdentifierExpression(privId) {
|
|
if (!isExpressionNode(privId)) {
|
|
return void 0;
|
|
}
|
|
const links = getNodeLinks(privId);
|
|
if (links.resolvedSymbol === void 0) {
|
|
links.resolvedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privId.escapedText, privId);
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) {
|
|
return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
|
|
}
|
|
function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) {
|
|
let propertyOnType;
|
|
const properties = getPropertiesOfType(leftType);
|
|
if (properties) {
|
|
forEach(properties, (symbol) => {
|
|
const decl = symbol.valueDeclaration;
|
|
if (decl && isNamedDeclaration(decl) && isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) {
|
|
propertyOnType = symbol;
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
const diagName = diagnosticName(right);
|
|
if (propertyOnType) {
|
|
const typeValueDecl = Debug.checkDefined(propertyOnType.valueDeclaration);
|
|
const typeClass = Debug.checkDefined(getContainingClass(typeValueDecl));
|
|
if (lexicallyScopedIdentifier == null ? void 0 : lexicallyScopedIdentifier.valueDeclaration) {
|
|
const lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration;
|
|
const lexicalClass = getContainingClass(lexicalValueDecl);
|
|
Debug.assert(!!lexicalClass);
|
|
if (findAncestor(lexicalClass, (n) => typeClass === n)) {
|
|
const diagnostic = error(
|
|
right,
|
|
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)
|
|
);
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(
|
|
lexicalValueDecl,
|
|
Diagnostics.The_shadowing_declaration_of_0_is_defined_here,
|
|
diagName
|
|
),
|
|
createDiagnosticForNode(
|
|
typeValueDecl,
|
|
Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here,
|
|
diagName
|
|
)
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
error(
|
|
right,
|
|
Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier,
|
|
diagName,
|
|
diagnosticName(typeClass.name || anon)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isThisPropertyAccessInConstructor(node, prop) {
|
|
return (isConstructorDeclaredProperty(prop) || isThisProperty(node) && isAutoTypedProperty(prop)) && getThisContainer(node, true) === getDeclaringConstructor(prop);
|
|
}
|
|
function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode) {
|
|
const parentSymbol = getNodeLinks(left).resolvedSymbol;
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
|
|
const isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
|
|
let prop;
|
|
if (isPrivateIdentifier(right)) {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
if (assignmentKind !== 0 /* None */) {
|
|
checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldSet */);
|
|
}
|
|
if (assignmentKind !== 1 /* Definite */) {
|
|
checkExternalEmitHelpers(node, 524288 /* ClassPrivateFieldGet */);
|
|
}
|
|
}
|
|
const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
|
|
if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
|
|
grammarErrorOnNode(right, Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, idText(right));
|
|
}
|
|
if (isAnyLike) {
|
|
if (lexicallyScopedSymbol) {
|
|
return isErrorType(apparentType) ? errorType : apparentType;
|
|
}
|
|
if (!getContainingClass(right)) {
|
|
grammarErrorOnNode(right, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
return anyType;
|
|
}
|
|
}
|
|
prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : void 0;
|
|
if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) {
|
|
return errorType;
|
|
} else {
|
|
const isSetonlyAccessor = prop && prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
if (isSetonlyAccessor && assignmentKind !== 1 /* Definite */) {
|
|
error(node, Diagnostics.Private_accessor_was_defined_without_a_getter);
|
|
}
|
|
}
|
|
} else {
|
|
if (isAnyLike) {
|
|
if (isIdentifier(left) && parentSymbol) {
|
|
markAliasReferenced(parentSymbol, node);
|
|
}
|
|
return isErrorType(apparentType) ? errorType : apparentType;
|
|
}
|
|
prop = getPropertyOfType(apparentType, right.escapedText, false, node.kind === 163 /* QualifiedName */);
|
|
}
|
|
if (isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 302 /* EnumMember */)) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
|
|
markAliasReferenced(parentSymbol, node);
|
|
}
|
|
let propType;
|
|
if (!prop) {
|
|
const indexInfo = !isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getApplicableIndexInfoForName(apparentType, right.escapedText) : void 0;
|
|
if (!(indexInfo && indexInfo.type)) {
|
|
const isUncheckedJS = isUncheckedJSSuggestion(node, leftType.symbol, true);
|
|
if (!isUncheckedJS && isJSLiteralType(leftType)) {
|
|
return anyType;
|
|
}
|
|
if (leftType.symbol === globalThisSymbol) {
|
|
if (globalThisSymbol.exports.has(right.escapedText) && globalThisSymbol.exports.get(right.escapedText).flags & 418 /* BlockScoped */) {
|
|
error(right, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(right.escapedText), typeToString(leftType));
|
|
} else if (noImplicitAny) {
|
|
error(right, 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, isThisTypeParameter(leftType) ? apparentType : leftType, isUncheckedJS);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
|
|
error(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
|
|
}
|
|
propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
|
|
if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
|
|
error(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
|
|
}
|
|
if (indexInfo.declaration && getCombinedNodeFlags(indexInfo.declaration) & 268435456 /* 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;
|
|
const writing = isWriteAccess(node);
|
|
checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, writing, apparentType, prop);
|
|
if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
|
|
error(right, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, idText(right));
|
|
return errorType;
|
|
}
|
|
propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
|
|
}
|
|
return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
|
|
}
|
|
function isUncheckedJSSuggestion(node, suggestion, excludeClasses) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (file) {
|
|
if (compilerOptions.checkJs === void 0 && file.checkJsDirective === void 0 && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */)) {
|
|
const declarationFile = forEach(suggestion == null ? void 0 : suggestion.declarations, getSourceFileOfNode);
|
|
return !(file !== declarationFile && !!declarationFile && isGlobalSourceFile(declarationFile)) && !(excludeClasses && suggestion && suggestion.flags & 32 /* Class */) && !(!!node && excludeClasses && isPropertyAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getFlowTypeOfAccessExpression(node, prop, propType, errorNode, checkMode) {
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
if (assignmentKind === 1 /* Definite */) {
|
|
return removeMissingType(propType, !!(prop && prop.flags & 16777216 /* Optional */));
|
|
}
|
|
if (prop && !(prop.flags & (3 /* Variable */ | 4 /* Property */ | 98304 /* Accessor */)) && !(prop.flags & 8192 /* Method */ && propType.flags & 1048576 /* Union */) && !isDuplicatedCommonJSExport(prop.declarations)) {
|
|
return propType;
|
|
}
|
|
if (propType === autoType) {
|
|
return getFlowTypeOfProperty(node, prop);
|
|
}
|
|
propType = getNarrowableTypeForReference(propType, node, checkMode);
|
|
let assumeUninitialized = false;
|
|
if (strictNullChecks && strictPropertyInitialization && isAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */) {
|
|
const declaration = prop && prop.valueDeclaration;
|
|
if (declaration && isPropertyWithoutInitializer(declaration)) {
|
|
if (!isStatic(declaration)) {
|
|
const flowContainer = getControlFlowContainer(node);
|
|
if (flowContainer.kind === 173 /* Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
assumeUninitialized = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (strictNullChecks && prop && prop.valueDeclaration && isPropertyAccessExpression(prop.valueDeclaration) && getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) && getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) {
|
|
assumeUninitialized = true;
|
|
}
|
|
const flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
|
|
if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) {
|
|
error(errorNode, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop));
|
|
return propType;
|
|
}
|
|
return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
|
|
}
|
|
function checkPropertyNotUsedBeforeDeclaration(prop, node, right) {
|
|
const { valueDeclaration } = prop;
|
|
if (!valueDeclaration || getSourceFileOfNode(node).isDeclarationFile) {
|
|
return;
|
|
}
|
|
let diagnosticMessage;
|
|
const declarationName = idText(right);
|
|
if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlags(valueDeclaration) & 32 /* Static */) && (compilerOptions.useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
|
|
diagnosticMessage = error(right, Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
|
|
} else if (valueDeclaration.kind === 260 /* ClassDeclaration */ && node.parent.kind !== 180 /* TypeReference */ && !(valueDeclaration.flags & 16777216 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
|
|
diagnosticMessage = error(right, Diagnostics.Class_0_used_before_its_declaration, declarationName);
|
|
}
|
|
if (diagnosticMessage) {
|
|
addRelatedInfo(
|
|
diagnosticMessage,
|
|
createDiagnosticForNode(valueDeclaration, Diagnostics._0_is_declared_here, declarationName)
|
|
);
|
|
}
|
|
}
|
|
function isInPropertyInitializerOrClassStaticBlock(node) {
|
|
return !!findAncestor(node, (node2) => {
|
|
switch (node2.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
case 299 /* PropertyAssignment */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 301 /* SpreadAssignment */:
|
|
case 164 /* ComputedPropertyName */:
|
|
case 236 /* TemplateSpan */:
|
|
case 291 /* JsxExpression */:
|
|
case 288 /* JsxAttribute */:
|
|
case 289 /* JsxAttributes */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 294 /* HeritageClause */:
|
|
return false;
|
|
case 216 /* ArrowFunction */:
|
|
case 241 /* ExpressionStatement */:
|
|
return isBlock(node2.parent) && isClassStaticBlockDeclaration(node2.parent.parent) ? true : "quit";
|
|
default:
|
|
return isExpressionNode(node2) ? false : "quit";
|
|
}
|
|
});
|
|
}
|
|
function isPropertyDeclaredInAncestorClass(prop) {
|
|
if (!(prop.parent.flags & 32 /* Class */)) {
|
|
return false;
|
|
}
|
|
let classType = getTypeOfSymbol(prop.parent);
|
|
while (true) {
|
|
classType = classType.symbol && getSuperClass(classType);
|
|
if (!classType) {
|
|
return false;
|
|
}
|
|
const superProperty = getPropertyOfType(classType, prop.escapedName);
|
|
if (superProperty && superProperty.valueDeclaration) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function getSuperClass(classType) {
|
|
const x = getBaseTypes(classType);
|
|
if (x.length === 0) {
|
|
return void 0;
|
|
}
|
|
return getIntersectionType(x);
|
|
}
|
|
function reportNonexistentProperty(propNode, containingType, isUncheckedJS) {
|
|
let errorInfo;
|
|
let relatedInfo;
|
|
if (!isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* Union */ && !(containingType.flags & 131068 /* Primitive */)) {
|
|
for (const subtype of containingType.types) {
|
|
if (!getPropertyOfType(subtype, propNode.escapedText) && !getApplicableIndexInfoForName(subtype, propNode.escapedText)) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(subtype));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (typeHasStaticProperty(propNode.escapedText, containingType)) {
|
|
const propName = declarationNameToString(propNode);
|
|
const typeName = typeToString(containingType);
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "." + propName);
|
|
} else {
|
|
const promisedType = getPromisedTypeOfPromise(containingType);
|
|
if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(containingType));
|
|
relatedInfo = createDiagnosticForNode(propNode, Diagnostics.Did_you_forget_to_use_await);
|
|
} else {
|
|
const missingProperty = declarationNameToString(propNode);
|
|
const container = typeToString(containingType);
|
|
const libSuggestion = getSuggestedLibForNonExistentProperty(missingProperty, containingType);
|
|
if (libSuggestion !== void 0) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, 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 {
|
|
const suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType);
|
|
if (suggestion !== void 0) {
|
|
const suggestedName = symbolName(suggestion);
|
|
const message = isUncheckedJS ? Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2 : Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2;
|
|
errorInfo = chainDiagnosticMessages(errorInfo, message, missingProperty, container, suggestedName);
|
|
relatedInfo = suggestion.valueDeclaration && createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestedName);
|
|
} else {
|
|
const diagnostic = containerSeemsToBeEmptyDomElement(containingType) ? Diagnostics.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom : Diagnostics.Property_0_does_not_exist_on_type_1;
|
|
errorInfo = chainDiagnosticMessages(elaborateNeverIntersection(errorInfo, containingType), diagnostic, missingProperty, container);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const resultDiagnostic = createDiagnosticForNodeFromMessageChain(propNode, errorInfo);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(resultDiagnostic, relatedInfo);
|
|
}
|
|
addErrorOrSuggestion(!isUncheckedJS || errorInfo.code !== 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, (type) => type.symbol && /^(EventTarget|Node|((HTML[a-zA-Z]*)?Element))$/.test(unescapeLeadingUnderscores(type.symbol.escapedName))) && isEmptyObjectType(containingType);
|
|
}
|
|
function typeHasStaticProperty(propName, containingType) {
|
|
const prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName);
|
|
return prop !== void 0 && !!prop.valueDeclaration && isStatic(prop.valueDeclaration);
|
|
}
|
|
function getSuggestedLibForNonExistentName(name) {
|
|
const missingName = diagnosticName(name);
|
|
const allFeatures = getScriptTargetFeatures();
|
|
const libTargets = getOwnKeys(allFeatures);
|
|
for (const libTarget of libTargets) {
|
|
const containingTypes = getOwnKeys(allFeatures[libTarget]);
|
|
if (containingTypes !== void 0 && contains(containingTypes, missingName)) {
|
|
return libTarget;
|
|
}
|
|
}
|
|
}
|
|
function getSuggestedLibForNonExistentProperty(missingProperty, containingType) {
|
|
const container = getApparentType(containingType).symbol;
|
|
if (!container) {
|
|
return void 0;
|
|
}
|
|
const allFeatures = getScriptTargetFeatures();
|
|
const libTargets = getOwnKeys(allFeatures);
|
|
for (const libTarget of libTargets) {
|
|
const featuresOfLib = allFeatures[libTarget];
|
|
const featuresOfContainingType = featuresOfLib[symbolName(container)];
|
|
if (featuresOfContainingType !== void 0 && contains(featuresOfContainingType, missingProperty)) {
|
|
return libTarget;
|
|
}
|
|
}
|
|
}
|
|
function getSuggestedSymbolForNonexistentClassMember(name, baseType) {
|
|
return getSpellingSuggestionForName(name, getPropertiesOfType(baseType), 106500 /* ClassMember */);
|
|
}
|
|
function getSuggestedSymbolForNonexistentProperty(name, containingType) {
|
|
let props = getPropertiesOfType(containingType);
|
|
if (typeof name !== "string") {
|
|
const parent = name.parent;
|
|
if (isPropertyAccessExpression(parent)) {
|
|
props = filter(props, (prop) => isValidPropertyAccessForCompletions(parent, containingType, prop));
|
|
}
|
|
name = idText(name);
|
|
}
|
|
return getSpellingSuggestionForName(name, props, 111551 /* Value */);
|
|
}
|
|
function getSuggestedSymbolForNonexistentJSXAttribute(name, containingType) {
|
|
const strName = isString(name) ? name : idText(name);
|
|
const properties = getPropertiesOfType(containingType);
|
|
const jsxSpecific = strName === "for" ? find(properties, (x) => symbolName(x) === "htmlFor") : strName === "class" ? find(properties, (x) => symbolName(x) === "className") : void 0;
|
|
return jsxSpecific != null ? jsxSpecific : getSpellingSuggestionForName(strName, properties, 111551 /* Value */);
|
|
}
|
|
function getSuggestionForNonexistentProperty(name, containingType) {
|
|
const suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
|
|
return suggestion && symbolName(suggestion);
|
|
}
|
|
function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) {
|
|
Debug.assert(outerName !== void 0, "outername should always be defined");
|
|
const result = resolveNameHelper(location, outerName, meaning, void 0, outerName, false, false, true, (symbols, name, meaning2) => {
|
|
Debug.assertEqual(outerName, name, "name should equal outerName");
|
|
const symbol = getSymbol(symbols, name, meaning2);
|
|
if (symbol)
|
|
return symbol;
|
|
let candidates;
|
|
if (symbols === globals) {
|
|
const primitives = mapDefined(
|
|
["string", "number", "boolean", "object", "bigint", "symbol"],
|
|
(s) => symbols.has(s.charAt(0).toUpperCase() + s.slice(1)) ? createSymbol(524288 /* TypeAlias */, s) : void 0
|
|
);
|
|
candidates = primitives.concat(arrayFrom(symbols.values()));
|
|
} else {
|
|
candidates = arrayFrom(symbols.values());
|
|
}
|
|
return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), candidates, meaning2);
|
|
});
|
|
return result;
|
|
}
|
|
function getSuggestionForNonexistentSymbol(location, outerName, meaning) {
|
|
const symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning);
|
|
return symbolResult && symbolName(symbolResult);
|
|
}
|
|
function getSuggestedSymbolForNonexistentModule(name, targetModule) {
|
|
return targetModule.exports && getSpellingSuggestionForName(idText(name), getExportsOfModuleAsArray(targetModule), 2623475 /* ModuleMember */);
|
|
}
|
|
function getSuggestionForNonexistentExport(name, targetModule) {
|
|
const suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule);
|
|
return suggestion && symbolName(suggestion);
|
|
}
|
|
function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
|
|
function hasProp(name) {
|
|
const prop = getPropertyOfObjectType(objectType, name);
|
|
if (prop) {
|
|
const s = getSingleCallSignature(getTypeOfSymbol(prop));
|
|
return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0));
|
|
}
|
|
return false;
|
|
}
|
|
const suggestedMethod = isAssignmentTarget(expr) ? "set" : "get";
|
|
if (!hasProp(suggestedMethod)) {
|
|
return void 0;
|
|
}
|
|
let suggestion = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (suggestion === void 0) {
|
|
suggestion = suggestedMethod;
|
|
} else {
|
|
suggestion += "." + suggestedMethod;
|
|
}
|
|
return suggestion;
|
|
}
|
|
function getSuggestedTypeForNonexistentStringLiteralType(source, target) {
|
|
const candidates = target.types.filter((type) => !!(type.flags & 128 /* StringLiteral */));
|
|
return getSpellingSuggestion(source.value, candidates, (type) => type.value);
|
|
}
|
|
function getSpellingSuggestionForName(name, symbols, meaning) {
|
|
return getSpellingSuggestion(name, symbols, getCandidateName);
|
|
function getCandidateName(candidate) {
|
|
const candidateName = symbolName(candidate);
|
|
if (startsWith(candidateName, '"')) {
|
|
return void 0;
|
|
}
|
|
if (candidate.flags & meaning) {
|
|
return candidateName;
|
|
}
|
|
if (candidate.flags & 2097152 /* Alias */) {
|
|
const alias = tryResolveAlias(candidate);
|
|
if (alias && alias.flags & meaning) {
|
|
return candidateName;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isSelfTypeAccess2) {
|
|
const valueDeclaration = prop && prop.flags & 106500 /* ClassMember */ && prop.valueDeclaration;
|
|
if (!valueDeclaration) {
|
|
return;
|
|
}
|
|
const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 8 /* Private */);
|
|
const hasPrivateIdentifier = prop.valueDeclaration && isNamedDeclaration(prop.valueDeclaration) && isPrivateIdentifier(prop.valueDeclaration.name);
|
|
if (!hasPrivateModifier && !hasPrivateIdentifier) {
|
|
return;
|
|
}
|
|
if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
|
|
return;
|
|
}
|
|
if (isSelfTypeAccess2) {
|
|
const containingMethod = findAncestor(nodeForCheckWriteOnly, isFunctionLikeDeclaration);
|
|
if (containingMethod && containingMethod.symbol === prop) {
|
|
return;
|
|
}
|
|
}
|
|
(getCheckFlags(prop) & 1 /* Instantiated */ ? getSymbolLinks(prop).target : prop).isReferenced = 67108863 /* All */;
|
|
}
|
|
function isSelfTypeAccess(name, parent) {
|
|
return name.kind === 108 /* ThisKeyword */ || !!parent && isEntityNameExpression(name) && parent === getResolvedSymbol(getFirstIdentifier(name));
|
|
}
|
|
function isValidPropertyAccess(node, propertyName) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return isValidPropertyAccessWithType(node, node.expression.kind === 106 /* SuperKeyword */, propertyName, getWidenedType(checkExpression(node.expression)));
|
|
case 163 /* QualifiedName */:
|
|
return isValidPropertyAccessWithType(node, false, propertyName, getWidenedType(checkExpression(node.left)));
|
|
case 202 /* ImportType */:
|
|
return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
|
|
}
|
|
}
|
|
function isValidPropertyAccessForCompletions(node, type, property) {
|
|
return isPropertyAccessible(
|
|
node,
|
|
node.kind === 208 /* PropertyAccessExpression */ && node.expression.kind === 106 /* SuperKeyword */,
|
|
false,
|
|
type,
|
|
property
|
|
);
|
|
}
|
|
function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
|
|
if (isTypeAny(type)) {
|
|
return true;
|
|
}
|
|
const prop = getPropertyOfType(type, propertyName);
|
|
return !!prop && isPropertyAccessible(node, isSuper, false, type, prop);
|
|
}
|
|
function isPropertyAccessible(node, isSuper, isWrite, containingType, property) {
|
|
if (isTypeAny(containingType)) {
|
|
return true;
|
|
}
|
|
if (property.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property.valueDeclaration)) {
|
|
const declClass = getContainingClass(property.valueDeclaration);
|
|
return !isOptionalChain(node) && !!findAncestor(node, (parent) => parent === declClass);
|
|
}
|
|
return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property);
|
|
}
|
|
function getForInVariableSymbol(node) {
|
|
const initializer = node.initializer;
|
|
if (initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variable = initializer.declarations[0];
|
|
if (variable && !isBindingPattern(variable.name)) {
|
|
return getSymbolOfNode(variable);
|
|
}
|
|
} else if (initializer.kind === 79 /* Identifier */) {
|
|
return getResolvedSymbol(initializer);
|
|
}
|
|
return void 0;
|
|
}
|
|
function hasNumericPropertyNames(type) {
|
|
return getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, numberType);
|
|
}
|
|
function isForInVariableForNumericPropertyNames(expr) {
|
|
const e = skipParentheses(expr);
|
|
if (e.kind === 79 /* Identifier */) {
|
|
const symbol = getResolvedSymbol(e);
|
|
if (symbol.flags & 3 /* Variable */) {
|
|
let child = expr;
|
|
let node = expr.parent;
|
|
while (node) {
|
|
if (node.kind === 246 /* 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 /* OptionalChain */ ? checkElementAccessChain(node, checkMode) : checkElementAccessExpression(node, checkNonNullExpression(node.expression), checkMode);
|
|
}
|
|
function checkElementAccessChain(node, checkMode) {
|
|
const exprType = checkExpression(node.expression);
|
|
const nonOptionalType = getOptionalExpressionType(exprType, node.expression);
|
|
return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression), checkMode), node, nonOptionalType !== exprType);
|
|
}
|
|
function checkElementAccessExpression(node, exprType, checkMode) {
|
|
const objectType = getAssignmentTargetKind(node) !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
|
|
const indexExpression = node.argumentExpression;
|
|
const indexType = checkExpression(indexExpression);
|
|
if (isErrorType(objectType) || objectType === silentNeverType) {
|
|
return objectType;
|
|
}
|
|
if (isConstEnumObjectType(objectType) && !isStringLiteralLike(indexExpression)) {
|
|
error(indexExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
|
|
return errorType;
|
|
}
|
|
const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
|
|
const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
|
|
const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
|
|
return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
|
|
}
|
|
function callLikeExpressionMayHaveTypeArguments(node) {
|
|
return isCallOrNewExpression(node) || isTaggedTemplateExpression(node) || isJsxOpeningLikeElement(node);
|
|
}
|
|
function resolveUntypedCall(node) {
|
|
if (callLikeExpressionMayHaveTypeArguments(node)) {
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
}
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
checkExpression(node.template);
|
|
} else if (isJsxOpeningLikeElement(node)) {
|
|
checkExpression(node.attributes);
|
|
} else if (node.kind !== 167 /* Decorator */) {
|
|
forEach(node.arguments, (argument) => {
|
|
checkExpression(argument);
|
|
});
|
|
}
|
|
return anySignature;
|
|
}
|
|
function resolveErrorCall(node) {
|
|
resolveUntypedCall(node);
|
|
return unknownSignature;
|
|
}
|
|
function reorderCandidates(signatures, result, callChainFlags) {
|
|
let lastParent;
|
|
let lastSymbol;
|
|
let cutoffIndex = 0;
|
|
let index;
|
|
let specializedIndex = -1;
|
|
let spliceIndex;
|
|
Debug.assert(!result.length);
|
|
for (const signature of signatures) {
|
|
const symbol = signature.declaration && getSymbolOfNode(signature.declaration);
|
|
const parent = signature.declaration && signature.declaration.parent;
|
|
if (!lastSymbol || symbol === lastSymbol) {
|
|
if (lastParent && parent === lastParent) {
|
|
index = index + 1;
|
|
} else {
|
|
lastParent = parent;
|
|
index = cutoffIndex;
|
|
}
|
|
} else {
|
|
index = cutoffIndex = result.length;
|
|
lastParent = parent;
|
|
}
|
|
lastSymbol = symbol;
|
|
if (signatureHasLiteralTypes(signature)) {
|
|
specializedIndex++;
|
|
spliceIndex = specializedIndex;
|
|
cutoffIndex++;
|
|
} else {
|
|
spliceIndex = index;
|
|
}
|
|
result.splice(spliceIndex, 0, callChainFlags ? getOptionalCallSignature(signature, callChainFlags) : signature);
|
|
}
|
|
}
|
|
function isSpreadArgument(arg) {
|
|
return !!arg && (arg.kind === 227 /* SpreadElement */ || arg.kind === 234 /* SyntheticExpression */ && arg.isSpread);
|
|
}
|
|
function getSpreadArgumentIndex(args) {
|
|
return findIndex(args, isSpreadArgument);
|
|
}
|
|
function acceptsVoid(t) {
|
|
return !!(t.flags & 16384 /* Void */);
|
|
}
|
|
function acceptsVoidUndefinedUnknownOrAny(t) {
|
|
return !!(t.flags & (16384 /* Void */ | 32768 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */));
|
|
}
|
|
function hasCorrectArity(node, args, signature, signatureHelpTrailingComma = false) {
|
|
let argCount;
|
|
let callIsIncomplete = false;
|
|
let effectiveParameterCount = getParameterCount(signature);
|
|
let effectiveMinimumArguments = getMinArgumentCount(signature);
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
argCount = args.length;
|
|
if (node.template.kind === 225 /* TemplateExpression */) {
|
|
const lastSpan = last(node.template.templateSpans);
|
|
callIsIncomplete = nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
|
|
} else {
|
|
const templateLiteral = node.template;
|
|
Debug.assert(templateLiteral.kind === 14 /* NoSubstitutionTemplateLiteral */);
|
|
callIsIncomplete = !!templateLiteral.isUnterminated;
|
|
}
|
|
} else if (node.kind === 167 /* Decorator */) {
|
|
argCount = getDecoratorArgumentCount(node, signature);
|
|
} else if (isJsxOpeningLikeElement(node)) {
|
|
callIsIncomplete = node.attributes.end === node.end;
|
|
if (callIsIncomplete) {
|
|
return true;
|
|
}
|
|
argCount = effectiveMinimumArguments === 0 ? args.length : 1;
|
|
effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1;
|
|
effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1);
|
|
} else if (!node.arguments) {
|
|
Debug.assert(node.kind === 211 /* NewExpression */);
|
|
return getMinArgumentCount(signature) === 0;
|
|
} else {
|
|
argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;
|
|
callIsIncomplete = node.arguments.end === node.end;
|
|
const spreadArgIndex = getSpreadArgumentIndex(args);
|
|
if (spreadArgIndex >= 0) {
|
|
return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature));
|
|
}
|
|
}
|
|
if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) {
|
|
return false;
|
|
}
|
|
if (callIsIncomplete || argCount >= effectiveMinimumArguments) {
|
|
return true;
|
|
}
|
|
for (let i = argCount; i < effectiveMinimumArguments; i++) {
|
|
const type = getTypeAtPosition(signature, i);
|
|
if (filterType(type, isInJSFile(node) && !strictNullChecks ? acceptsVoidUndefinedUnknownOrAny : acceptsVoid).flags & 131072 /* Never */) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function hasCorrectTypeArgumentArity(signature, typeArguments) {
|
|
const numTypeParameters = length(signature.typeParameters);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters);
|
|
return !some(typeArguments) || typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters;
|
|
}
|
|
function getSingleCallSignature(type) {
|
|
return getSingleSignature(type, 0 /* Call */, false);
|
|
}
|
|
function getSingleCallOrConstructSignature(type) {
|
|
return getSingleSignature(type, 0 /* Call */, false) || getSingleSignature(type, 1 /* Construct */, false);
|
|
}
|
|
function getSingleSignature(type, kind, allowMembers) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
if (allowMembers || resolved.properties.length === 0 && resolved.indexInfos.length === 0) {
|
|
if (kind === 0 /* Call */ && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) {
|
|
return resolved.callSignatures[0];
|
|
}
|
|
if (kind === 1 /* Construct */ && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) {
|
|
return resolved.constructSignatures[0];
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
|
|
const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
|
|
const restType = getEffectiveRestType(contextualSignature);
|
|
const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
|
|
const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
|
|
applyToParameterTypes(sourceSignature, signature, (source, target) => {
|
|
inferTypes(context.inferences, source, target);
|
|
});
|
|
if (!inferenceContext) {
|
|
applyToReturnTypes(contextualSignature, signature, (source, target) => {
|
|
inferTypes(context.inferences, source, target, 128 /* ReturnType */);
|
|
});
|
|
}
|
|
return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
|
|
}
|
|
function inferJsxTypeArguments(node, signature, checkMode, context) {
|
|
const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
|
|
const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
|
|
inferTypes(context.inferences, checkAttrType, paramType);
|
|
return getInferredTypes(context);
|
|
}
|
|
function getThisArgumentType(thisArgumentNode) {
|
|
if (!thisArgumentNode) {
|
|
return voidType;
|
|
}
|
|
const thisArgumentType = checkExpression(thisArgumentNode);
|
|
return isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : thisArgumentType;
|
|
}
|
|
function inferTypeArguments(node, signature, args, checkMode, context) {
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
return inferJsxTypeArguments(node, signature, checkMode, context);
|
|
}
|
|
if (node.kind !== 167 /* Decorator */) {
|
|
const skipBindingPatterns = every(signature.typeParameters, (p) => !!getDefaultFromTypeParameter(p));
|
|
const contextualType = getContextualType(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
|
|
if (contextualType) {
|
|
const inferenceTargetType = getReturnTypeOfSignature(signature);
|
|
if (couldContainTypeVariables(inferenceTargetType)) {
|
|
const outerContext = getInferenceContext(node);
|
|
const isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* SkipBindingPatterns */) !== contextualType;
|
|
if (!isFromBindingPattern) {
|
|
const outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
|
|
const instantiatedType = instantiateType(contextualType, outerMapper);
|
|
const contextualSignature = getSingleCallSignature(instantiatedType);
|
|
const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
|
|
inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
|
|
}
|
|
const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
|
|
const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
|
|
inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
|
|
context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
|
|
}
|
|
}
|
|
}
|
|
const restType = getNonArrayRestType(signature);
|
|
const argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
|
|
if (restType && restType.flags & 262144 /* TypeParameter */) {
|
|
const info = find(context.inferences, (info2) => info2.typeParameter === restType);
|
|
if (info) {
|
|
info.impliedArity = findIndex(args, isSpreadArgument, argCount) < 0 ? args.length - argCount : void 0;
|
|
}
|
|
}
|
|
const thisType = getThisTypeOfSignature(signature);
|
|
if (thisType && couldContainTypeVariables(thisType)) {
|
|
const thisArgumentNode = getThisArgumentOfCall(node);
|
|
inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
|
|
}
|
|
for (let i = 0; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (arg.kind !== 229 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
|
|
const paramType = getTypeAtPosition(signature, i);
|
|
if (couldContainTypeVariables(paramType)) {
|
|
const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
|
|
inferTypes(context.inferences, argType, paramType);
|
|
}
|
|
}
|
|
}
|
|
if (restType && couldContainTypeVariables(restType)) {
|
|
const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
|
|
inferTypes(context.inferences, spreadType, restType);
|
|
}
|
|
return getInferredTypes(context);
|
|
}
|
|
function getMutableArrayOrTupleType(type) {
|
|
return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.elementFlags, false, type.target.labeledElementDeclarations) : createTupleType([type], [8 /* Variadic */]);
|
|
}
|
|
function getSpreadArgumentType(args, index, argCount, restType, context, checkMode) {
|
|
if (index >= argCount - 1) {
|
|
const arg = args[argCount - 1];
|
|
if (isSpreadArgument(arg)) {
|
|
return getMutableArrayOrTupleType(arg.kind === 234 /* SyntheticExpression */ ? arg.type : checkExpressionWithContextualType(arg.expression, restType, context, checkMode));
|
|
}
|
|
}
|
|
const types = [];
|
|
const flags = [];
|
|
const names = [];
|
|
for (let i = index; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (isSpreadArgument(arg)) {
|
|
const spreadType = arg.kind === 234 /* SyntheticExpression */ ? arg.type : checkExpression(arg.expression);
|
|
if (isArrayLikeType(spreadType)) {
|
|
types.push(spreadType);
|
|
flags.push(8 /* Variadic */);
|
|
} else {
|
|
types.push(checkIteratedTypeOrElementType(33 /* Spread */, spreadType, undefinedType, arg.kind === 227 /* SpreadElement */ ? arg.expression : arg));
|
|
flags.push(4 /* Rest */);
|
|
}
|
|
} else {
|
|
const contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
|
|
const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
|
|
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
|
|
types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
|
|
flags.push(1 /* Required */);
|
|
}
|
|
if (arg.kind === 234 /* SyntheticExpression */ && arg.tupleNameSource) {
|
|
names.push(arg.tupleNameSource);
|
|
}
|
|
}
|
|
return createTupleType(types, flags, false, length(names) === length(types) ? names : void 0);
|
|
}
|
|
function checkTypeArguments(signature, typeArgumentNodes, reportErrors2, headMessage) {
|
|
const isJavascript = isInJSFile(signature.declaration);
|
|
const typeParameters = signature.typeParameters;
|
|
const typeArgumentTypes = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript);
|
|
let mapper;
|
|
for (let i = 0; i < typeArgumentNodes.length; i++) {
|
|
Debug.assert(typeParameters[i] !== void 0, "Should not call checkTypeArguments with too many type arguments");
|
|
const constraint = getConstraintOfTypeParameter(typeParameters[i]);
|
|
if (constraint) {
|
|
const errorInfo = reportErrors2 && headMessage ? () => chainDiagnosticMessages(void 0, Diagnostics.Type_0_does_not_satisfy_the_constraint_1) : void 0;
|
|
const typeArgumentHeadMessage = headMessage || Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
|
|
if (!mapper) {
|
|
mapper = createTypeMapper(typeParameters, typeArgumentTypes);
|
|
}
|
|
const typeArgument = typeArgumentTypes[i];
|
|
if (!checkTypeAssignableTo(
|
|
typeArgument,
|
|
getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
|
|
reportErrors2 ? typeArgumentNodes[i] : void 0,
|
|
typeArgumentHeadMessage,
|
|
errorInfo
|
|
)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return typeArgumentTypes;
|
|
}
|
|
function getJsxReferenceKind(node) {
|
|
if (isJsxIntrinsicIdentifier(node.tagName)) {
|
|
return 2 /* Mixed */;
|
|
}
|
|
const tagType = getApparentType(checkExpression(node.tagName));
|
|
if (length(getSignaturesOfType(tagType, 1 /* Construct */))) {
|
|
return 0 /* Component */;
|
|
}
|
|
if (length(getSignaturesOfType(tagType, 0 /* Call */))) {
|
|
return 1 /* Function */;
|
|
}
|
|
return 2 /* Mixed */;
|
|
}
|
|
function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) {
|
|
const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
|
|
const attributesType = checkExpressionWithContextualType(node.attributes, paramType, void 0, checkMode);
|
|
return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
|
|
attributesType,
|
|
paramType,
|
|
relation,
|
|
reportErrors2 ? node.tagName : void 0,
|
|
node.attributes,
|
|
void 0,
|
|
containingMessageChain,
|
|
errorOutputContainer
|
|
);
|
|
function checkTagNameDoesNotExpectTooManyArguments() {
|
|
var _a2;
|
|
if (getJsxNamespaceContainerForImplicitImport(node)) {
|
|
return true;
|
|
}
|
|
const tagType = isJsxOpeningElement(node) || isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : void 0;
|
|
if (!tagType) {
|
|
return true;
|
|
}
|
|
const tagCallSignatures = getSignaturesOfType(tagType, 0 /* Call */);
|
|
if (!length(tagCallSignatures)) {
|
|
return true;
|
|
}
|
|
const factory2 = getJsxFactoryEntity(node);
|
|
if (!factory2) {
|
|
return true;
|
|
}
|
|
const factorySymbol = resolveEntityName(factory2, 111551 /* Value */, true, false, node);
|
|
if (!factorySymbol) {
|
|
return true;
|
|
}
|
|
const factoryType = getTypeOfSymbol(factorySymbol);
|
|
const callSignatures = getSignaturesOfType(factoryType, 0 /* Call */);
|
|
if (!length(callSignatures)) {
|
|
return true;
|
|
}
|
|
let hasFirstParamSignatures = false;
|
|
let maxParamCount = 0;
|
|
for (const sig of callSignatures) {
|
|
const firstparam = getTypeAtPosition(sig, 0);
|
|
const signaturesOfParam = getSignaturesOfType(firstparam, 0 /* Call */);
|
|
if (!length(signaturesOfParam))
|
|
continue;
|
|
for (const paramSig of signaturesOfParam) {
|
|
hasFirstParamSignatures = true;
|
|
if (hasEffectiveRestParameter(paramSig)) {
|
|
return true;
|
|
}
|
|
const paramCount = getParameterCount(paramSig);
|
|
if (paramCount > maxParamCount) {
|
|
maxParamCount = paramCount;
|
|
}
|
|
}
|
|
}
|
|
if (!hasFirstParamSignatures) {
|
|
return true;
|
|
}
|
|
let absoluteMinArgCount = Infinity;
|
|
for (const tagSig of tagCallSignatures) {
|
|
const tagRequiredArgCount = getMinArgumentCount(tagSig);
|
|
if (tagRequiredArgCount < absoluteMinArgCount) {
|
|
absoluteMinArgCount = tagRequiredArgCount;
|
|
}
|
|
}
|
|
if (absoluteMinArgCount <= maxParamCount) {
|
|
return true;
|
|
}
|
|
if (reportErrors2) {
|
|
const diag2 = createDiagnosticForNode(node.tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(node.tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount);
|
|
const tagNameDeclaration = (_a2 = getSymbolAtLocation(node.tagName)) == null ? void 0 : _a2.valueDeclaration;
|
|
if (tagNameDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(node.tagName)));
|
|
}
|
|
if (errorOutputContainer && errorOutputContainer.skipLogging) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
if (!errorOutputContainer.skipLogging) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain) {
|
|
const errorOutputContainer = { errors: void 0, skipLogging: true };
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "jsx should have errors when reporting errors");
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
return void 0;
|
|
}
|
|
const thisType = getThisTypeOfSignature(signature);
|
|
if (thisType && thisType !== voidType && node.kind !== 211 /* NewExpression */) {
|
|
const thisArgumentNode = getThisArgumentOfCall(node);
|
|
const thisArgumentType = getThisArgumentType(thisArgumentNode);
|
|
const errorNode = reportErrors2 ? thisArgumentNode || node : void 0;
|
|
const headMessage2 = Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
|
|
if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage2, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors");
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
const headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
|
|
const restType = getNonArrayRestType(signature);
|
|
const argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
|
|
for (let i = 0; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (arg.kind !== 229 /* OmittedExpression */) {
|
|
const paramType = getTypeAtPosition(signature, i);
|
|
const argType = checkExpressionWithContextualType(arg, paramType, void 0, checkMode);
|
|
const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
|
|
if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? arg : void 0, arg, headMessage, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
|
|
maybeAddMissingAwaitInfo(arg, checkArgType, paramType);
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
}
|
|
if (restType) {
|
|
const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, void 0, checkMode);
|
|
const restArgCount = args.length - argCount;
|
|
const errorNode = !reportErrors2 ? void 0 : restArgCount === 0 ? node : restArgCount === 1 ? args[argCount] : setTextRangePosEnd(createSyntheticExpression(node, spreadType), args[argCount].pos, args[args.length - 1].end);
|
|
if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, void 0, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors");
|
|
maybeAddMissingAwaitInfo(errorNode, spreadType, restType);
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
return void 0;
|
|
function maybeAddMissingAwaitInfo(errorNode, source, target) {
|
|
if (errorNode && reportErrors2 && errorOutputContainer.errors && errorOutputContainer.errors.length) {
|
|
if (getAwaitedTypeOfPromise(target)) {
|
|
return;
|
|
}
|
|
const awaitedTypeOfSource = getAwaitedTypeOfPromise(source);
|
|
if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) {
|
|
addRelatedInfo(errorOutputContainer.errors[0], createDiagnosticForNode(errorNode, Diagnostics.Did_you_forget_to_use_await));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getThisArgumentOfCall(node) {
|
|
const expression = node.kind === 210 /* CallExpression */ ? node.expression : node.kind === 212 /* TaggedTemplateExpression */ ? node.tag : void 0;
|
|
if (expression) {
|
|
const callee = skipOuterExpressions(expression);
|
|
if (isAccessExpression(callee)) {
|
|
return callee.expression;
|
|
}
|
|
}
|
|
}
|
|
function createSyntheticExpression(parent, type, isSpread, tupleNameSource) {
|
|
const result = parseNodeFactory.createSyntheticExpression(type, isSpread, tupleNameSource);
|
|
setTextRange(result, parent);
|
|
setParent(result, parent);
|
|
return result;
|
|
}
|
|
function getEffectiveCallArguments(node) {
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
const template = node.template;
|
|
const args2 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
|
|
if (template.kind === 225 /* TemplateExpression */) {
|
|
forEach(template.templateSpans, (span) => {
|
|
args2.push(span.expression);
|
|
});
|
|
}
|
|
return args2;
|
|
}
|
|
if (node.kind === 167 /* Decorator */) {
|
|
return getEffectiveDecoratorArguments(node);
|
|
}
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
return node.attributes.properties.length > 0 || isJsxOpeningElement(node) && node.parent.children.length > 0 ? [node.attributes] : emptyArray;
|
|
}
|
|
const args = node.arguments || emptyArray;
|
|
const spreadIndex = getSpreadArgumentIndex(args);
|
|
if (spreadIndex >= 0) {
|
|
const effectiveArgs = args.slice(0, spreadIndex);
|
|
for (let i = spreadIndex; i < args.length; i++) {
|
|
const arg = args[i];
|
|
const spreadType = arg.kind === 227 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
|
|
if (spreadType && isTupleType(spreadType)) {
|
|
forEach(getTypeArguments(spreadType), (t, i2) => {
|
|
var _a2;
|
|
const flags = spreadType.target.elementFlags[i2];
|
|
const syntheticArg = createSyntheticExpression(
|
|
arg,
|
|
flags & 4 /* Rest */ ? createArrayType(t) : t,
|
|
!!(flags & 12 /* Variable */),
|
|
(_a2 = spreadType.target.labeledElementDeclarations) == null ? void 0 : _a2[i2]
|
|
);
|
|
effectiveArgs.push(syntheticArg);
|
|
});
|
|
} else {
|
|
effectiveArgs.push(arg);
|
|
}
|
|
}
|
|
return effectiveArgs;
|
|
}
|
|
return args;
|
|
}
|
|
function getEffectiveDecoratorArguments(node) {
|
|
const parent = node.parent;
|
|
const expr = node.expression;
|
|
switch (parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return [
|
|
createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent)))
|
|
];
|
|
case 166 /* Parameter */:
|
|
const func = parent.parent;
|
|
return [
|
|
createSyntheticExpression(expr, parent.parent.kind === 173 /* Constructor */ ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType),
|
|
createSyntheticExpression(expr, anyType),
|
|
createSyntheticExpression(expr, numberType)
|
|
];
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const hasPropDesc = languageVersion !== 0 /* ES3 */ && (!isPropertyDeclaration(parent) || hasAccessorModifier(parent));
|
|
return [
|
|
createSyntheticExpression(expr, getParentTypeOfClassElement(parent)),
|
|
createSyntheticExpression(expr, getClassElementPropertyKeyType(parent)),
|
|
createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent)) : anyType)
|
|
];
|
|
}
|
|
return Debug.fail();
|
|
}
|
|
function getDecoratorArgumentCount(node, signature) {
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return 1;
|
|
case 169 /* PropertyDeclaration */:
|
|
return hasAccessorModifier(node.parent) ? 3 : 2;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return languageVersion === 0 /* ES3 */ || signature.parameters.length <= 2 ? 2 : 3;
|
|
case 166 /* Parameter */:
|
|
return 3;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
|
|
let start;
|
|
let length2;
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (isPropertyAccessExpression(node.expression)) {
|
|
const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
|
|
start = nameSpan.start;
|
|
length2 = doNotIncludeArguments ? nameSpan.length : node.end - start;
|
|
} else {
|
|
const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
|
|
start = expressionSpan.start;
|
|
length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start;
|
|
}
|
|
return { start, length: length2, sourceFile };
|
|
}
|
|
function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
|
|
if (isCallExpression(node)) {
|
|
const { sourceFile, start, length: length2 } = getDiagnosticSpanForCallNode(node);
|
|
return createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2, arg3);
|
|
} else {
|
|
return createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
}
|
|
function isPromiseResolveArityError(node) {
|
|
if (!isCallExpression(node) || !isIdentifier(node.expression))
|
|
return false;
|
|
const symbol = resolveName(node.expression, node.expression.escapedText, 111551 /* Value */, void 0, void 0, false);
|
|
const decl = symbol == null ? void 0 : symbol.valueDeclaration;
|
|
if (!decl || !isParameter(decl) || !isFunctionExpressionOrArrowFunction(decl.parent) || !isNewExpression(decl.parent.parent) || !isIdentifier(decl.parent.parent.expression)) {
|
|
return false;
|
|
}
|
|
const globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
|
|
if (!globalPromiseSymbol)
|
|
return false;
|
|
const constructorSymbol = getSymbolAtLocation(decl.parent.parent.expression, true);
|
|
return constructorSymbol === globalPromiseSymbol;
|
|
}
|
|
function getArgumentArityError(node, signatures, args) {
|
|
var _a2;
|
|
const spreadIndex = getSpreadArgumentIndex(args);
|
|
if (spreadIndex > -1) {
|
|
return createDiagnosticForNode(args[spreadIndex], Diagnostics.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter);
|
|
}
|
|
let min2 = Number.POSITIVE_INFINITY;
|
|
let max = Number.NEGATIVE_INFINITY;
|
|
let maxBelow = Number.NEGATIVE_INFINITY;
|
|
let minAbove = Number.POSITIVE_INFINITY;
|
|
let closestSignature;
|
|
for (const sig of signatures) {
|
|
const minParameter = getMinArgumentCount(sig);
|
|
const maxParameter = getParameterCount(sig);
|
|
if (minParameter < min2) {
|
|
min2 = minParameter;
|
|
closestSignature = sig;
|
|
}
|
|
max = Math.max(max, maxParameter);
|
|
if (minParameter < args.length && minParameter > maxBelow)
|
|
maxBelow = minParameter;
|
|
if (args.length < maxParameter && maxParameter < minAbove)
|
|
minAbove = maxParameter;
|
|
}
|
|
const hasRestParameter2 = some(signatures, hasEffectiveRestParameter);
|
|
const parameterRange = hasRestParameter2 ? min2 : min2 < max ? min2 + "-" + max : min2;
|
|
const isVoidPromiseError = !hasRestParameter2 && parameterRange === 1 && args.length === 0 && isPromiseResolveArityError(node);
|
|
if (isVoidPromiseError && isInJSFile(node)) {
|
|
return getDiagnosticForCallNode(node, Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments);
|
|
}
|
|
const error2 = hasRestParameter2 ? Diagnostics.Expected_at_least_0_arguments_but_got_1 : isVoidPromiseError ? Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise : Diagnostics.Expected_0_arguments_but_got_1;
|
|
if (min2 < args.length && args.length < max) {
|
|
return getDiagnosticForCallNode(node, 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 < min2) {
|
|
const diagnostic = getDiagnosticForCallNode(node, error2, parameterRange, args.length);
|
|
const parameter = (_a2 = closestSignature == null ? void 0 : closestSignature.declaration) == null ? void 0 : _a2.parameters[closestSignature.thisParameter ? args.length + 1 : args.length];
|
|
if (parameter) {
|
|
const parameterError = createDiagnosticForNode(
|
|
parameter,
|
|
isBindingPattern(parameter.name) ? Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : isRestParameter(parameter) ? Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided : Diagnostics.An_argument_for_0_was_not_provided,
|
|
!parameter.name ? args.length : !isBindingPattern(parameter.name) ? idText(getFirstIdentifier(parameter.name)) : void 0
|
|
);
|
|
return addRelatedInfo(diagnostic, parameterError);
|
|
}
|
|
return diagnostic;
|
|
} else {
|
|
const errorSpan = factory.createNodeArray(args.slice(max));
|
|
const pos = first(errorSpan).pos;
|
|
let end = last(errorSpan).end;
|
|
if (end === pos) {
|
|
end++;
|
|
}
|
|
setTextRangePosEnd(errorSpan, pos, end);
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), errorSpan, error2, parameterRange, args.length);
|
|
}
|
|
}
|
|
function getTypeArgumentArityError(node, signatures, typeArguments) {
|
|
const argCount = typeArguments.length;
|
|
if (signatures.length === 1) {
|
|
const sig = signatures[0];
|
|
const min2 = getMinTypeArgumentCount(sig.typeParameters);
|
|
const max = length(sig.typeParameters);
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, min2 < max ? min2 + "-" + max : min2, argCount);
|
|
}
|
|
let belowArgCount = -Infinity;
|
|
let aboveArgCount = Infinity;
|
|
for (const sig of signatures) {
|
|
const min2 = getMinTypeArgumentCount(sig.typeParameters);
|
|
const max = length(sig.typeParameters);
|
|
if (min2 > argCount) {
|
|
aboveArgCount = Math.min(aboveArgCount, min2);
|
|
} else if (max < argCount) {
|
|
belowArgCount = Math.max(belowArgCount, max);
|
|
}
|
|
}
|
|
if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) {
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
|
|
}
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
|
|
}
|
|
function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) {
|
|
const isTaggedTemplate = node.kind === 212 /* TaggedTemplateExpression */;
|
|
const isDecorator2 = node.kind === 167 /* Decorator */;
|
|
const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
|
|
const reportErrors2 = !candidatesOutArray;
|
|
let typeArguments;
|
|
if (!isDecorator2 && !isSuperCall(node)) {
|
|
typeArguments = node.typeArguments;
|
|
if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 106 /* SuperKeyword */) {
|
|
forEach(typeArguments, checkSourceElement);
|
|
}
|
|
}
|
|
const candidates = candidatesOutArray || [];
|
|
reorderCandidates(signatures, candidates, callChainFlags);
|
|
if (!candidates.length) {
|
|
if (reportErrors2) {
|
|
diagnostics.add(getDiagnosticForCallNode(node, Diagnostics.Call_target_does_not_contain_any_signatures));
|
|
}
|
|
return resolveErrorCall(node);
|
|
}
|
|
const args = getEffectiveCallArguments(node);
|
|
const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
|
|
let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
|
|
argCheckMode |= checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
|
|
let candidatesForArgumentError;
|
|
let candidateForArgumentArityError;
|
|
let candidateForTypeArgumentError;
|
|
let result;
|
|
const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 210 /* CallExpression */ && node.arguments.hasTrailingComma;
|
|
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);
|
|
getNodeLinks(node).resolvedSignature = result;
|
|
if (reportErrors2) {
|
|
if (candidatesForArgumentError) {
|
|
if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) {
|
|
const last2 = candidatesForArgumentError[candidatesForArgumentError.length - 1];
|
|
let chain;
|
|
if (candidatesForArgumentError.length > 3) {
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.The_last_overload_gave_the_following_error);
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.No_overload_matches_this_call);
|
|
}
|
|
const diags = getSignatureApplicabilityError(node, args, last2, assignableRelation, 0 /* Normal */, true, () => chain);
|
|
if (diags) {
|
|
for (const d of diags) {
|
|
if (last2.declaration && candidatesForArgumentError.length > 3) {
|
|
addRelatedInfo(d, createDiagnosticForNode(last2.declaration, Diagnostics.The_last_overload_is_declared_here));
|
|
}
|
|
addImplementationSuccessElaboration(last2, d);
|
|
diagnostics.add(d);
|
|
}
|
|
} else {
|
|
Debug.fail("No error for last overload signature");
|
|
}
|
|
} else {
|
|
const allDiagnostics = [];
|
|
let max = 0;
|
|
let min2 = Number.MAX_VALUE;
|
|
let minIndex = 0;
|
|
let i = 0;
|
|
for (const c of candidatesForArgumentError) {
|
|
const chain2 = () => chainDiagnosticMessages(void 0, Diagnostics.Overload_0_of_1_2_gave_the_following_error, i + 1, candidates.length, signatureToString(c));
|
|
const diags2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* Normal */, true, chain2);
|
|
if (diags2) {
|
|
if (diags2.length <= min2) {
|
|
min2 = diags2.length;
|
|
minIndex = i;
|
|
}
|
|
max = Math.max(max, diags2.length);
|
|
allDiagnostics.push(diags2);
|
|
} else {
|
|
Debug.fail("No error for 3 or fewer overload signatures");
|
|
}
|
|
i++;
|
|
}
|
|
const diags = max > 1 ? allDiagnostics[minIndex] : flatten(allDiagnostics);
|
|
Debug.assert(diags.length > 0, "No errors reported for 3 or fewer overload signatures");
|
|
const chain = chainDiagnosticMessages(
|
|
map(diags, createDiagnosticMessageChainFromDiagnostic),
|
|
Diagnostics.No_overload_matches_this_call
|
|
);
|
|
const related = [...flatMap(diags, (d) => d.relatedInformation)];
|
|
let diag2;
|
|
if (every(diags, (d) => d.start === diags[0].start && d.length === diags[0].length && d.file === diags[0].file)) {
|
|
const { file, start, length: length2 } = diags[0];
|
|
diag2 = { file, start, length: length2, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
|
|
} else {
|
|
diag2 = createDiagnosticForNodeFromMessageChain(node, chain, related);
|
|
}
|
|
addImplementationSuccessElaboration(candidatesForArgumentError[0], diag2);
|
|
diagnostics.add(diag2);
|
|
}
|
|
} else if (candidateForArgumentArityError) {
|
|
diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args));
|
|
} else if (candidateForTypeArgumentError) {
|
|
checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError);
|
|
} else {
|
|
const signaturesWithCorrectTypeArgumentArity = filter(signatures, (s) => hasCorrectTypeArgumentArity(s, typeArguments));
|
|
if (signaturesWithCorrectTypeArgumentArity.length === 0) {
|
|
diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments));
|
|
} else if (!isDecorator2) {
|
|
diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args));
|
|
} else if (fallbackError) {
|
|
diagnostics.add(getDiagnosticForCallNode(node, fallbackError));
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
function addImplementationSuccessElaboration(failed, diagnostic) {
|
|
var _a2, _b;
|
|
const oldCandidatesForArgumentError = candidatesForArgumentError;
|
|
const oldCandidateForArgumentArityError = candidateForArgumentArityError;
|
|
const oldCandidateForTypeArgumentError = candidateForTypeArgumentError;
|
|
const failedSignatureDeclarations = ((_b = (_a2 = failed.declaration) == null ? void 0 : _a2.symbol) == null ? void 0 : _b.declarations) || emptyArray;
|
|
const isOverload = failedSignatureDeclarations.length > 1;
|
|
const implDecl = isOverload ? find(failedSignatureDeclarations, (d) => isFunctionLikeDeclaration(d) && nodeIsPresent(d.body)) : void 0;
|
|
if (implDecl) {
|
|
const candidate = getSignatureFromDeclaration(implDecl);
|
|
const isSingleNonGenericCandidate2 = !candidate.typeParameters;
|
|
if (chooseOverload([candidate], assignableRelation, isSingleNonGenericCandidate2)) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(implDecl, 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(candidates2, relation, isSingleNonGenericCandidate2, signatureHelpTrailingComma2 = false) {
|
|
candidatesForArgumentError = void 0;
|
|
candidateForArgumentArityError = void 0;
|
|
candidateForTypeArgumentError = void 0;
|
|
if (isSingleNonGenericCandidate2) {
|
|
const candidate = candidates2[0];
|
|
if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
|
|
return void 0;
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, candidate, relation, 0 /* Normal */, false, void 0)) {
|
|
candidatesForArgumentError = [candidate];
|
|
return void 0;
|
|
}
|
|
return candidate;
|
|
}
|
|
for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
|
|
const candidate = candidates2[candidateIndex];
|
|
if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
|
|
continue;
|
|
}
|
|
let checkCandidate;
|
|
let inferenceContext;
|
|
if (candidate.typeParameters) {
|
|
let typeArgumentTypes;
|
|
if (some(typeArguments)) {
|
|
typeArgumentTypes = checkTypeArguments(candidate, typeArguments, false);
|
|
if (!typeArgumentTypes) {
|
|
candidateForTypeArgumentError = candidate;
|
|
continue;
|
|
}
|
|
} else {
|
|
inferenceContext = createInferenceContext(candidate.typeParameters, candidate, isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
|
|
typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
|
|
argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
|
|
}
|
|
checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
|
|
if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
|
|
candidateForArgumentArityError = checkCandidate;
|
|
continue;
|
|
}
|
|
} else {
|
|
checkCandidate = candidate;
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, void 0)) {
|
|
(candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
|
|
continue;
|
|
}
|
|
if (argCheckMode) {
|
|
argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
|
|
if (inferenceContext) {
|
|
const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
|
|
checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
|
|
if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
|
|
candidateForArgumentArityError = checkCandidate;
|
|
continue;
|
|
}
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, void 0)) {
|
|
(candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
|
|
continue;
|
|
}
|
|
}
|
|
candidates2[candidateIndex] = checkCandidate;
|
|
return checkCandidate;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) {
|
|
Debug.assert(candidates.length > 0);
|
|
checkNodeDeferred(node);
|
|
return hasCandidatesOutArray || candidates.length === 1 || candidates.some((c) => !!c.typeParameters) ? pickLongestCandidateSignature(node, candidates, args, checkMode) : createUnionOfSignaturesForOverloadFailure(candidates);
|
|
}
|
|
function createUnionOfSignaturesForOverloadFailure(candidates) {
|
|
const thisParameters = mapDefined(candidates, (c) => c.thisParameter);
|
|
let thisParameter;
|
|
if (thisParameters.length) {
|
|
thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter));
|
|
}
|
|
const { min: minArgumentCount, max: maxNonRestParam } = minAndMax(candidates, getNumNonRestParameters);
|
|
const parameters = [];
|
|
for (let i = 0; i < maxNonRestParam; i++) {
|
|
const symbols = mapDefined(candidates, (s) => signatureHasRestParameter(s) ? i < s.parameters.length - 1 ? s.parameters[i] : last(s.parameters) : i < s.parameters.length ? s.parameters[i] : void 0);
|
|
Debug.assert(symbols.length !== 0);
|
|
parameters.push(createCombinedSymbolFromTypes(symbols, mapDefined(candidates, (candidate) => tryGetTypeAtPosition(candidate, i))));
|
|
}
|
|
const restParameterSymbols = mapDefined(candidates, (c) => signatureHasRestParameter(c) ? last(c.parameters) : void 0);
|
|
let flags = 0 /* None */;
|
|
if (restParameterSymbols.length !== 0) {
|
|
const type = createArrayType(getUnionType(mapDefined(candidates, tryGetRestTypeOfSignature), 2 /* Subtype */));
|
|
parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type));
|
|
flags |= 1 /* HasRestParameter */;
|
|
}
|
|
if (candidates.some(signatureHasLiteralTypes)) {
|
|
flags |= 2 /* HasLiteralTypes */;
|
|
}
|
|
return createSignature(
|
|
candidates[0].declaration,
|
|
void 0,
|
|
thisParameter,
|
|
parameters,
|
|
getIntersectionType(candidates.map(getReturnTypeOfSignature)),
|
|
void 0,
|
|
minArgumentCount,
|
|
flags
|
|
);
|
|
}
|
|
function getNumNonRestParameters(signature) {
|
|
const numParams = signature.parameters.length;
|
|
return signatureHasRestParameter(signature) ? numParams - 1 : numParams;
|
|
}
|
|
function createCombinedSymbolFromTypes(sources, types) {
|
|
return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2 /* Subtype */));
|
|
}
|
|
function createCombinedSymbolForOverloadFailure(sources, type) {
|
|
return createSymbolWithType(first(sources), type);
|
|
}
|
|
function pickLongestCandidateSignature(node, candidates, args, checkMode) {
|
|
const bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === void 0 ? args.length : apparentArgumentCount);
|
|
const candidate = candidates[bestIndex];
|
|
const { typeParameters } = candidate;
|
|
if (!typeParameters) {
|
|
return candidate;
|
|
}
|
|
const typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : void 0;
|
|
const instantiated = typeArgumentNodes ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isInJSFile(node))) : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
|
|
candidates[bestIndex] = instantiated;
|
|
return instantiated;
|
|
}
|
|
function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) {
|
|
const 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) {
|
|
const inferenceContext = createInferenceContext(typeParameters, candidate, isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
|
|
const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
|
|
return createSignatureInstantiation(candidate, typeArgumentTypes);
|
|
}
|
|
function getLongestCandidateIndex(candidates, argsCount) {
|
|
let maxParamsIndex = -1;
|
|
let maxParams = -1;
|
|
for (let i = 0; i < candidates.length; i++) {
|
|
const candidate = candidates[i];
|
|
const 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 /* SuperKeyword */) {
|
|
const superType = checkSuperExpression(node.expression);
|
|
if (isTypeAny(superType)) {
|
|
for (const arg of node.arguments) {
|
|
checkExpression(arg);
|
|
}
|
|
return anySignature;
|
|
}
|
|
if (!isErrorType(superType)) {
|
|
const baseTypeNode = getEffectiveBaseTypeNode(getContainingClass(node));
|
|
if (baseTypeNode) {
|
|
const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
|
|
return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
let callChainFlags;
|
|
let funcType = checkExpression(node.expression);
|
|
if (isCallChain(node)) {
|
|
const nonOptionalType = getOptionalExpressionType(funcType, node.expression);
|
|
callChainFlags = nonOptionalType === funcType ? 0 /* None */ : isOutermostOptionalChain(node) ? 16 /* IsOuterCallChain */ : 8 /* IsInnerCallChain */;
|
|
funcType = nonOptionalType;
|
|
} else {
|
|
callChainFlags = 0 /* None */;
|
|
}
|
|
funcType = checkNonNullTypeWithReporter(
|
|
funcType,
|
|
node.expression,
|
|
reportCannotInvokePossiblyNullOrUndefinedError
|
|
);
|
|
if (funcType === silentNeverType) {
|
|
return silentNeverSignature;
|
|
}
|
|
const apparentType = getApparentType(funcType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
if (!isErrorType(funcType) && node.typeArguments) {
|
|
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (!callSignatures.length) {
|
|
if (numConstructSignatures) {
|
|
error(node, Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
|
|
} else {
|
|
let relatedInformation;
|
|
if (node.arguments.length === 1) {
|
|
const text = getSourceFileOfNode(node).text;
|
|
if (isLineBreak(text.charCodeAt(skipTrivia(text, node.expression.end, true) - 1))) {
|
|
relatedInformation = createDiagnosticForNode(node.expression, Diagnostics.Are_you_missing_a_semicolon);
|
|
}
|
|
}
|
|
invocationError(node.expression, apparentType, 0 /* Call */, relatedInformation);
|
|
}
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
|
|
skippedGenericFunction(node, checkMode);
|
|
return resolvingSignature;
|
|
}
|
|
if (callSignatures.some((sig) => isInJSFile(sig.declaration) && !!getJSDocClassTag(sig.declaration))) {
|
|
error(node, 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)));
|
|
}
|
|
function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
|
|
return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
|
|
}
|
|
function resolveNewExpression(node, candidatesOutArray, checkMode) {
|
|
if (node.arguments && languageVersion < 1 /* ES5 */) {
|
|
const spreadIndex = getSpreadArgumentIndex(node.arguments);
|
|
if (spreadIndex >= 0) {
|
|
error(node.arguments[spreadIndex], Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
|
|
}
|
|
}
|
|
let expressionType = checkNonNullExpression(node.expression);
|
|
if (expressionType === silentNeverType) {
|
|
return silentNeverSignature;
|
|
}
|
|
expressionType = getApparentType(expressionType);
|
|
if (isErrorType(expressionType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (isTypeAny(expressionType)) {
|
|
if (node.typeArguments) {
|
|
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
const constructSignatures = getSignaturesOfType(expressionType, 1 /* Construct */);
|
|
if (constructSignatures.length) {
|
|
if (!isConstructorAccessible(node, constructSignatures[0])) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (someSignature(constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */))) {
|
|
error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
|
|
return resolveErrorCall(node);
|
|
}
|
|
const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
|
|
if (valueDecl && hasSyntacticModifier(valueDecl, 256 /* Abstract */)) {
|
|
error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
const callSignatures = getSignaturesOfType(expressionType, 0 /* Call */);
|
|
if (callSignatures.length) {
|
|
const signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
if (!noImplicitAny) {
|
|
if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) {
|
|
error(node, Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
|
|
}
|
|
if (getThisTypeOfSignature(signature) === voidType) {
|
|
error(node, 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 /* Construct */);
|
|
return resolveErrorCall(node);
|
|
}
|
|
function someSignature(signatures, f) {
|
|
if (isArray(signatures)) {
|
|
return some(signatures, (signature) => someSignature(signature, f));
|
|
}
|
|
return signatures.compositeKind === 1048576 /* Union */ ? some(signatures.compositeSignatures, f) : f(signatures);
|
|
}
|
|
function typeHasProtectedAccessibleBase(target, type) {
|
|
const baseTypes = getBaseTypes(type);
|
|
if (!length(baseTypes)) {
|
|
return false;
|
|
}
|
|
const firstBase = baseTypes[0];
|
|
if (firstBase.flags & 2097152 /* Intersection */) {
|
|
const types = firstBase.types;
|
|
const mixinFlags = findMixins(types);
|
|
let i = 0;
|
|
for (const intersectionMember of firstBase.types) {
|
|
if (!mixinFlags[i]) {
|
|
if (getObjectFlags(intersectionMember) & (1 /* Class */ | 2 /* 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;
|
|
}
|
|
const declaration = signature.declaration;
|
|
const modifiers = getSelectedEffectiveModifierFlags(declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
if (!modifiers || declaration.kind !== 173 /* Constructor */) {
|
|
return true;
|
|
}
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(declaration.parent.symbol);
|
|
const declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
|
|
if (!isNodeWithinClass(node, declaringClassDeclaration)) {
|
|
const containingClass = getContainingClass(node);
|
|
if (containingClass && modifiers & 16 /* Protected */) {
|
|
const containingType = getTypeOfNode(containingClass);
|
|
if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (modifiers & 8 /* Private */) {
|
|
error(node, Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
|
|
}
|
|
if (modifiers & 16 /* Protected */) {
|
|
error(node, 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) {
|
|
let errorInfo;
|
|
const isCall = kind === 0 /* Call */;
|
|
const awaitedType = getAwaitedType(apparentType);
|
|
const maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0;
|
|
if (apparentType.flags & 1048576 /* Union */) {
|
|
const types = apparentType.types;
|
|
let hasSignatures = false;
|
|
for (const constituent of types) {
|
|
const signatures = getSignaturesOfType(constituent, kind);
|
|
if (signatures.length !== 0) {
|
|
hasSignatures = true;
|
|
if (errorInfo) {
|
|
break;
|
|
}
|
|
} else {
|
|
if (!errorInfo) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Type_0_has_no_call_signatures : Diagnostics.Type_0_has_no_construct_signatures,
|
|
typeToString(constituent)
|
|
);
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Not_all_constituents_of_type_0_are_callable : Diagnostics.Not_all_constituents_of_type_0_are_constructable,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
if (hasSignatures) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!hasSignatures) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
void 0,
|
|
isCall ? Diagnostics.No_constituent_of_type_0_is_callable : Diagnostics.No_constituent_of_type_0_is_constructable,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
if (!errorInfo) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other : 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 = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Type_0_has_no_call_signatures : Diagnostics.Type_0_has_no_construct_signatures,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
let headMessage = isCall ? Diagnostics.This_expression_is_not_callable : Diagnostics.This_expression_is_not_constructable;
|
|
if (isCallExpression(errorTarget.parent) && errorTarget.parent.arguments.length === 0) {
|
|
const { resolvedSymbol } = getNodeLinks(errorTarget);
|
|
if (resolvedSymbol && resolvedSymbol.flags & 32768 /* GetAccessor */) {
|
|
headMessage = Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without;
|
|
}
|
|
}
|
|
return {
|
|
messageChain: chainDiagnosticMessages(errorInfo, headMessage),
|
|
relatedMessage: maybeMissingAwait ? Diagnostics.Did_you_forget_to_use_await : void 0
|
|
};
|
|
}
|
|
function invocationError(errorTarget, apparentType, kind, relatedInformation) {
|
|
const { messageChain, relatedMessage: relatedInfo } = invocationErrorDetails(errorTarget, apparentType, kind);
|
|
const diagnostic = createDiagnosticForNodeFromMessageChain(errorTarget, messageChain);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
|
|
}
|
|
if (isCallExpression(errorTarget.parent)) {
|
|
const { start, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent, true);
|
|
diagnostic.start = start;
|
|
diagnostic.length = length2;
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
invocationErrorRecovery(apparentType, kind, relatedInformation ? addRelatedInfo(diagnostic, relatedInformation) : diagnostic);
|
|
}
|
|
function invocationErrorRecovery(apparentType, kind, diagnostic) {
|
|
if (!apparentType.symbol) {
|
|
return;
|
|
}
|
|
const importNode = getSymbolLinks(apparentType.symbol).originatingImport;
|
|
if (importNode && !isImportCall(importNode)) {
|
|
const sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind);
|
|
if (!sigs || !sigs.length)
|
|
return;
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(importNode, 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) {
|
|
const tagType = checkExpression(node.tag);
|
|
const apparentType = getApparentType(tagType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (!callSignatures.length) {
|
|
if (isArrayLiteralExpression(node.parent)) {
|
|
const diagnostic = createDiagnosticForNode(node.tag, 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 /* Call */);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
function getDiagnosticHeadMessageForDecoratorResolution(node) {
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression;
|
|
case 166 /* Parameter */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression;
|
|
case 169 /* PropertyDeclaration */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function resolveDecorator(node, candidatesOutArray, checkMode) {
|
|
const funcType = checkExpression(node.expression);
|
|
const apparentType = getApparentType(funcType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (isPotentiallyUncalledDecorator(node, callSignatures)) {
|
|
const nodeStr = getTextOfNode(node.expression, false);
|
|
error(node, 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);
|
|
}
|
|
const headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
|
|
if (!callSignatures.length) {
|
|
const errorDetails = invocationErrorDetails(node.expression, apparentType, 0 /* Call */);
|
|
const messageChain = chainDiagnosticMessages(errorDetails.messageChain, headMessage);
|
|
const diag2 = createDiagnosticForNodeFromMessageChain(node.expression, messageChain);
|
|
if (errorDetails.relatedMessage) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(node.expression, errorDetails.relatedMessage));
|
|
}
|
|
diagnostics.add(diag2);
|
|
invocationErrorRecovery(apparentType, 0 /* Call */, diag2);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */, headMessage);
|
|
}
|
|
function createSignatureForJSXIntrinsic(node, result) {
|
|
const namespace = getJsxNamespaceAt(node);
|
|
const exports = namespace && getExportsOfSymbol(namespace);
|
|
const typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968 /* Type */);
|
|
const returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968 /* Type */, node);
|
|
const declaration = factory.createFunctionTypeNode(
|
|
void 0,
|
|
[factory.createParameterDeclaration(void 0, void 0, "props", void 0, nodeBuilder.typeToTypeNode(result, node))],
|
|
returnNode ? factory.createTypeReferenceNode(returnNode, void 0) : factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
const parameterSymbol = createSymbol(1 /* FunctionScopedVariable */, "props");
|
|
parameterSymbol.type = result;
|
|
return createSignature(
|
|
declaration,
|
|
void 0,
|
|
void 0,
|
|
[parameterSymbol],
|
|
typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType,
|
|
void 0,
|
|
1,
|
|
0 /* None */
|
|
);
|
|
}
|
|
function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) {
|
|
if (isJsxIntrinsicIdentifier(node.tagName)) {
|
|
const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
|
|
const fakeSignature = createSignatureForJSXIntrinsic(node, result);
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), void 0, 0 /* Normal */), result, node.tagName, node.attributes);
|
|
if (length(node.typeArguments)) {
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments)));
|
|
}
|
|
return fakeSignature;
|
|
}
|
|
const exprTypes = checkExpression(node.tagName);
|
|
const apparentType = getApparentType(exprTypes);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
|
|
if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, 0)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (signatures.length === 0) {
|
|
error(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName));
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, signatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
function isPotentiallyUncalledDecorator(decorator, signatures) {
|
|
return signatures.length && every(signatures, (signature) => signature.minArgumentCount === 0 && !signatureHasRestParameter(signature) && signature.parameters.length < getDecoratorArgumentCount(decorator, signature));
|
|
}
|
|
function resolveSignature(node, candidatesOutArray, checkMode) {
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
return resolveCallExpression(node, candidatesOutArray, checkMode);
|
|
case 211 /* NewExpression */:
|
|
return resolveNewExpression(node, candidatesOutArray, checkMode);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode);
|
|
case 167 /* Decorator */:
|
|
return resolveDecorator(node, candidatesOutArray, checkMode);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
|
|
}
|
|
throw Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
|
|
}
|
|
function getResolvedSignature(node, candidatesOutArray, checkMode) {
|
|
const links = getNodeLinks(node);
|
|
const cached = links.resolvedSignature;
|
|
if (cached && cached !== resolvingSignature && !candidatesOutArray) {
|
|
return cached;
|
|
}
|
|
links.resolvedSignature = resolvingSignature;
|
|
const result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
|
|
if (result !== resolvingSignature) {
|
|
links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
|
|
}
|
|
return result;
|
|
}
|
|
function isJSConstructor(node) {
|
|
var _a2;
|
|
if (!node || !isInJSFile(node)) {
|
|
return false;
|
|
}
|
|
const func = isFunctionDeclaration(node) || isFunctionExpression(node) ? node : (isVariableDeclaration(node) || isPropertyAssignment(node)) && node.initializer && isFunctionExpression(node.initializer) ? node.initializer : void 0;
|
|
if (func) {
|
|
if (getJSDocClassTag(node))
|
|
return true;
|
|
if (isPropertyAssignment(walkUpParenthesizedExpressions(func.parent)))
|
|
return false;
|
|
const symbol = getSymbolOfNode(func);
|
|
return !!((_a2 = symbol == null ? void 0 : symbol.members) == null ? void 0 : _a2.size);
|
|
}
|
|
return false;
|
|
}
|
|
function mergeJSSymbols(target, source) {
|
|
var _a2, _b;
|
|
if (source) {
|
|
const links = getSymbolLinks(source);
|
|
if (!links.inferredClassSymbol || !links.inferredClassSymbol.has(getSymbolId(target))) {
|
|
const inferred = isTransientSymbol(target) ? target : cloneSymbol(target);
|
|
inferred.exports = inferred.exports || createSymbolTable();
|
|
inferred.members = inferred.members || createSymbolTable();
|
|
inferred.flags |= source.flags & 32 /* Class */;
|
|
if ((_a2 = source.exports) == null ? void 0 : _a2.size) {
|
|
mergeSymbolTable(inferred.exports, source.exports);
|
|
}
|
|
if ((_b = source.members) == null ? void 0 : _b.size) {
|
|
mergeSymbolTable(inferred.members, source.members);
|
|
}
|
|
(links.inferredClassSymbol || (links.inferredClassSymbol = /* @__PURE__ */ new Map())).set(getSymbolId(inferred), inferred);
|
|
return inferred;
|
|
}
|
|
return links.inferredClassSymbol.get(getSymbolId(target));
|
|
}
|
|
}
|
|
function getAssignedClassSymbol(decl) {
|
|
var _a2;
|
|
const assignmentSymbol = decl && getSymbolOfExpando(decl, true);
|
|
const prototype = (_a2 = assignmentSymbol == null ? void 0 : assignmentSymbol.exports) == null ? void 0 : _a2.get("prototype");
|
|
const init = (prototype == null ? void 0 : prototype.valueDeclaration) && getAssignedJSPrototype(prototype.valueDeclaration);
|
|
return init ? getSymbolOfNode(init) : void 0;
|
|
}
|
|
function getSymbolOfExpando(node, allowDeclaration) {
|
|
if (!node.parent) {
|
|
return void 0;
|
|
}
|
|
let name;
|
|
let decl;
|
|
if (isVariableDeclaration(node.parent) && node.parent.initializer === node) {
|
|
if (!isInJSFile(node) && !(isVarConst(node.parent) && isFunctionLikeDeclaration(node))) {
|
|
return void 0;
|
|
}
|
|
name = node.parent.name;
|
|
decl = node.parent;
|
|
} else if (isBinaryExpression(node.parent)) {
|
|
const parentNode = node.parent;
|
|
const parentNodeOperator = node.parent.operatorToken.kind;
|
|
if (parentNodeOperator === 63 /* EqualsToken */ && (allowDeclaration || parentNode.right === node)) {
|
|
name = parentNode.left;
|
|
decl = name;
|
|
} else if (parentNodeOperator === 56 /* BarBarToken */ || parentNodeOperator === 60 /* QuestionQuestionToken */) {
|
|
if (isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) {
|
|
name = parentNode.parent.name;
|
|
decl = parentNode.parent;
|
|
} else if (isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 63 /* EqualsToken */ && (allowDeclaration || parentNode.parent.right === parentNode)) {
|
|
name = parentNode.parent.left;
|
|
decl = name;
|
|
}
|
|
if (!name || !isBindableStaticNameExpression(name) || !isSameEntityName(name, parentNode.left)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
} else if (allowDeclaration && isFunctionDeclaration(node)) {
|
|
name = node.name;
|
|
decl = node;
|
|
}
|
|
if (!decl || !name || !allowDeclaration && !getExpandoInitializer(node, isPrototypeAccess(name))) {
|
|
return void 0;
|
|
}
|
|
return getSymbolOfNode(decl);
|
|
}
|
|
function getAssignedJSPrototype(node) {
|
|
if (!node.parent) {
|
|
return false;
|
|
}
|
|
let parent = node.parent;
|
|
while (parent && parent.kind === 208 /* PropertyAccessExpression */) {
|
|
parent = parent.parent;
|
|
}
|
|
if (parent && isBinaryExpression(parent) && isPrototypeAccess(parent.left) && parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const right = getInitializerOfBinaryExpression(parent);
|
|
return isObjectLiteralExpression(right) && right;
|
|
}
|
|
}
|
|
function checkCallExpression(node, checkMode) {
|
|
var _a2;
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
const signature = getResolvedSignature(node, void 0, checkMode);
|
|
if (signature === resolvingSignature) {
|
|
return silentNeverType;
|
|
}
|
|
checkDeprecatedSignature(signature, node);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return voidType;
|
|
}
|
|
if (node.kind === 211 /* NewExpression */) {
|
|
const declaration = signature.declaration;
|
|
if (declaration && declaration.kind !== 173 /* Constructor */ && declaration.kind !== 177 /* ConstructSignature */ && declaration.kind !== 182 /* ConstructorType */ && !isJSDocConstructSignature(declaration) && !isJSConstructor(declaration)) {
|
|
if (noImplicitAny) {
|
|
error(node, Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
|
|
}
|
|
return anyType;
|
|
}
|
|
}
|
|
if (isInJSFile(node) && isCommonJsRequire(node)) {
|
|
return resolveExternalModuleTypeByLiteral(node.arguments[0]);
|
|
}
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType.flags & 12288 /* ESSymbolLike */ && isSymbolOrSymbolForCall(node)) {
|
|
return getESSymbolLikeTypeForNode(walkUpParenthesizedExpressions(node.parent));
|
|
}
|
|
if (node.kind === 210 /* CallExpression */ && !node.questionDotToken && node.parent.kind === 241 /* ExpressionStatement */ && returnType.flags & 16384 /* Void */ && getTypePredicateOfSignature(signature)) {
|
|
if (!isDottedName(node.expression)) {
|
|
error(node.expression, Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name);
|
|
} else if (!getEffectsSignature(node)) {
|
|
const diagnostic = error(node.expression, Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation);
|
|
getTypeOfDottedName(node.expression, diagnostic);
|
|
}
|
|
}
|
|
if (isInJSFile(node)) {
|
|
const jsSymbol = getSymbolOfExpando(node, false);
|
|
if ((_a2 = jsSymbol == null ? void 0 : jsSymbol.exports) == null ? void 0 : _a2.size) {
|
|
const jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, emptyArray, emptyArray, emptyArray);
|
|
jsAssignmentType.objectFlags |= 4096 /* JSLiteral */;
|
|
return getIntersectionType([returnType, jsAssignmentType]);
|
|
}
|
|
}
|
|
return returnType;
|
|
}
|
|
function checkDeprecatedSignature(signature, node) {
|
|
if (signature.declaration && signature.declaration.flags & 268435456 /* Deprecated */) {
|
|
const suggestionNode = getDeprecatedSuggestionNode(node);
|
|
const name = tryGetPropertyAccessOrIdentifierToString(getInvokedExpression(node));
|
|
addDeprecatedSuggestionWithSignature(suggestionNode, signature.declaration, name, signatureToString(signature));
|
|
}
|
|
}
|
|
function getDeprecatedSuggestionNode(node) {
|
|
node = skipParentheses(node);
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
case 167 /* Decorator */:
|
|
case 211 /* NewExpression */:
|
|
return getDeprecatedSuggestionNode(node.expression);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return getDeprecatedSuggestionNode(node.tag);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return getDeprecatedSuggestionNode(node.tagName);
|
|
case 209 /* ElementAccessExpression */:
|
|
return node.argumentExpression;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.name;
|
|
case 180 /* TypeReference */:
|
|
const typeReference = node;
|
|
return isQualifiedName(typeReference.typeName) ? typeReference.typeName.right : typeReference;
|
|
default:
|
|
return node;
|
|
}
|
|
}
|
|
function isSymbolOrSymbolForCall(node) {
|
|
if (!isCallExpression(node))
|
|
return false;
|
|
let left = node.expression;
|
|
if (isPropertyAccessExpression(left) && left.name.escapedText === "for") {
|
|
left = left.expression;
|
|
}
|
|
if (!isIdentifier(left) || left.escapedText !== "Symbol") {
|
|
return false;
|
|
}
|
|
const globalESSymbol = getGlobalESSymbolConstructorSymbol(false);
|
|
if (!globalESSymbol) {
|
|
return false;
|
|
}
|
|
return globalESSymbol === resolveName(left, "Symbol", 111551 /* Value */, void 0, void 0, false);
|
|
}
|
|
function checkImportCallExpression(node) {
|
|
checkGrammarImportCallExpression(node);
|
|
if (node.arguments.length === 0) {
|
|
return createPromiseReturnType(node, anyType);
|
|
}
|
|
const specifier = node.arguments[0];
|
|
const specifierType = checkExpressionCached(specifier);
|
|
const optionsType = node.arguments.length > 1 ? checkExpressionCached(node.arguments[1]) : void 0;
|
|
for (let i = 2; i < node.arguments.length; ++i) {
|
|
checkExpressionCached(node.arguments[i]);
|
|
}
|
|
if (specifierType.flags & 32768 /* Undefined */ || specifierType.flags & 65536 /* Null */ || !isTypeAssignableTo(specifierType, stringType)) {
|
|
error(specifier, Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
|
|
}
|
|
if (optionsType) {
|
|
const importCallOptionsType = getGlobalImportCallOptionsType(true);
|
|
if (importCallOptionsType !== emptyObjectType) {
|
|
checkTypeAssignableTo(optionsType, getNullableType(importCallOptionsType, 32768 /* Undefined */), node.arguments[1]);
|
|
}
|
|
}
|
|
const moduleSymbol = resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
const esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, 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) {
|
|
const memberTable = createSymbolTable();
|
|
const newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
|
|
newSymbol.parent = originalSymbol;
|
|
newSymbol.nameType = getStringLiteralType("default");
|
|
newSymbol.aliasTarget = resolveSymbol(symbol);
|
|
memberTable.set("default" /* Default */, newSymbol);
|
|
return createAnonymousType(anonymousSymbol, memberTable, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) {
|
|
const hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier);
|
|
if (hasDefaultOnly && type && !isErrorType(type)) {
|
|
const synthType = type;
|
|
if (!synthType.defaultOnlyType) {
|
|
const type2 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
|
|
synthType.defaultOnlyType = type2;
|
|
}
|
|
return synthType.defaultOnlyType;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
|
|
var _a2;
|
|
if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
|
|
const synthType = type;
|
|
if (!synthType.syntheticType) {
|
|
const file = (_a2 = originalSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false, moduleSpecifier);
|
|
if (hasSyntheticDefault) {
|
|
const anonymousSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
const defaultContainingObject = createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol);
|
|
anonymousSymbol.type = defaultContainingObject;
|
|
synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, 0, false) : defaultContainingObject;
|
|
} else {
|
|
synthType.syntheticType = type;
|
|
}
|
|
}
|
|
return synthType.syntheticType;
|
|
}
|
|
return type;
|
|
}
|
|
function isCommonJsRequire(node) {
|
|
if (!isRequireCall(node, true)) {
|
|
return false;
|
|
}
|
|
if (!isIdentifier(node.expression))
|
|
return Debug.fail();
|
|
const resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551 /* Value */, void 0, void 0, true);
|
|
if (resolvedRequire === requireSymbol) {
|
|
return true;
|
|
}
|
|
if (resolvedRequire.flags & 2097152 /* Alias */) {
|
|
return false;
|
|
}
|
|
const targetDeclarationKind = resolvedRequire.flags & 16 /* Function */ ? 259 /* FunctionDeclaration */ : resolvedRequire.flags & 3 /* Variable */ ? 257 /* VariableDeclaration */ : 0 /* Unknown */;
|
|
if (targetDeclarationKind !== 0 /* Unknown */) {
|
|
const decl = getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
|
|
return !!decl && !!(decl.flags & 16777216 /* Ambient */);
|
|
}
|
|
return false;
|
|
}
|
|
function checkTaggedTemplateExpression(node) {
|
|
if (!checkGrammarTaggedTemplateChain(node))
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */);
|
|
}
|
|
const signature = getResolvedSignature(node);
|
|
checkDeprecatedSignature(signature, node);
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
function checkAssertion(node) {
|
|
if (node.kind === 213 /* TypeAssertionExpression */) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (file && fileExtensionIsOneOf(file.fileName, [".cts" /* Cts */, ".mts" /* Mts */])) {
|
|
grammarErrorOnNode(node, 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 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 225 /* TemplateExpression */:
|
|
return true;
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isValidConstAssertionArgument(node.expression);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const op = node.operator;
|
|
const arg = node.operand;
|
|
return op === 40 /* MinusToken */ && (arg.kind === 8 /* NumericLiteral */ || arg.kind === 9 /* BigIntLiteral */) || op === 39 /* PlusToken */ && arg.kind === 8 /* NumericLiteral */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = node.expression;
|
|
let symbol = getTypeOfNode(expr).symbol;
|
|
if (symbol && symbol.flags & 2097152 /* Alias */) {
|
|
symbol = resolveAlias(symbol);
|
|
}
|
|
return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */);
|
|
}
|
|
return false;
|
|
}
|
|
function checkAssertionWorker(errNode, type, expression, checkMode) {
|
|
let exprType = checkExpression(expression, checkMode);
|
|
if (isConstTypeReference(type)) {
|
|
if (!isValidConstAssertionArgument(expression)) {
|
|
error(expression, 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));
|
|
const targetType = getTypeFromTypeNode(type);
|
|
if (!isErrorType(targetType)) {
|
|
addLazyDiagnostic(() => {
|
|
const widenedType = getWidenedType(exprType);
|
|
if (!isTypeComparableTo(targetType, widenedType)) {
|
|
checkTypeComparableTo(
|
|
exprType,
|
|
targetType,
|
|
errNode,
|
|
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) {
|
|
const leftType = checkExpression(node.expression);
|
|
const nonOptionalType = getOptionalExpressionType(leftType, node.expression);
|
|
return propagateOptionalTypeMarker(getNonNullableType(nonOptionalType), node, nonOptionalType !== leftType);
|
|
}
|
|
function checkNonNullAssertion(node) {
|
|
return node.flags & 32 /* OptionalChain */ ? checkNonNullChain(node) : getNonNullableType(checkExpression(node.expression));
|
|
}
|
|
function checkExpressionWithTypeArguments(node) {
|
|
checkGrammarExpressionWithTypeArguments(node);
|
|
const exprType = node.kind === 230 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) : isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
|
|
const typeArguments = node.typeArguments;
|
|
if (exprType === silentNeverType || isErrorType(exprType) || !some(typeArguments)) {
|
|
return exprType;
|
|
}
|
|
let hasSomeApplicableSignature = false;
|
|
let nonApplicableType;
|
|
const result = getInstantiatedType(exprType);
|
|
const errorType2 = hasSomeApplicableSignature ? nonApplicableType : exprType;
|
|
if (errorType2) {
|
|
diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType2)));
|
|
}
|
|
return result;
|
|
function getInstantiatedType(type) {
|
|
let hasSignatures = false;
|
|
let hasApplicableSignature = false;
|
|
const result2 = getInstantiatedTypePart(type);
|
|
hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature);
|
|
if (hasSignatures && !hasApplicableSignature) {
|
|
nonApplicableType != null ? nonApplicableType : nonApplicableType = type;
|
|
}
|
|
return result2;
|
|
function getInstantiatedTypePart(type2) {
|
|
if (type2.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type2);
|
|
const callSignatures = getInstantiatedSignatures(resolved.callSignatures);
|
|
const 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) {
|
|
const result3 = createAnonymousType(void 0, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
|
|
result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
|
|
result3.node = node;
|
|
return result3;
|
|
}
|
|
} else if (type2.flags & 58982400 /* InstantiableNonPrimitive */) {
|
|
const constraint = getBaseConstraintOfType(type2);
|
|
if (constraint) {
|
|
const instantiated = getInstantiatedTypePart(constraint);
|
|
if (instantiated !== constraint) {
|
|
return instantiated;
|
|
}
|
|
}
|
|
} else if (type2.flags & 1048576 /* Union */) {
|
|
return mapType(type2, getInstantiatedType);
|
|
} else if (type2.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(sameMap(type2.types, getInstantiatedTypePart));
|
|
}
|
|
return type2;
|
|
}
|
|
}
|
|
function getInstantiatedSignatures(signatures) {
|
|
const applicableSignatures = filter(signatures, (sig) => !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments));
|
|
return sameMap(applicableSignatures, (sig) => {
|
|
const typeArgumentTypes = checkTypeArguments(sig, typeArguments, true);
|
|
return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, isInJSFile(sig.declaration)) : sig;
|
|
});
|
|
}
|
|
}
|
|
function checkSatisfiesExpression(node) {
|
|
checkSourceElement(node.type);
|
|
const targetType = getTypeFromTypeNode(node.type);
|
|
if (isErrorType(targetType)) {
|
|
return targetType;
|
|
}
|
|
const exprType = checkExpression(node.expression);
|
|
checkTypeAssignableToAndOptionallyElaborate(exprType, targetType, node.type, node.expression, Diagnostics.Type_0_does_not_satisfy_the_expected_type_1);
|
|
return exprType;
|
|
}
|
|
function checkMetaProperty(node) {
|
|
checkGrammarMetaProperty(node);
|
|
if (node.keywordToken === 103 /* NewKeyword */) {
|
|
return checkNewTargetMetaProperty(node);
|
|
}
|
|
if (node.keywordToken === 100 /* ImportKeyword */) {
|
|
return checkImportMetaProperty(node);
|
|
}
|
|
return Debug.assertNever(node.keywordToken);
|
|
}
|
|
function checkMetaPropertyKeyword(node) {
|
|
switch (node.keywordToken) {
|
|
case 100 /* ImportKeyword */:
|
|
return getGlobalImportMetaExpressionType();
|
|
case 103 /* NewKeyword */:
|
|
const type = checkNewTargetMetaProperty(node);
|
|
return isErrorType(type) ? errorType : createNewTargetExpressionType(type);
|
|
default:
|
|
Debug.assertNever(node.keywordToken);
|
|
}
|
|
}
|
|
function checkNewTargetMetaProperty(node) {
|
|
const container = getNewTargetContainer(node);
|
|
if (!container) {
|
|
error(node, 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 /* Constructor */) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
return getTypeOfSymbol(symbol);
|
|
} else {
|
|
const symbol = getSymbolOfNode(container);
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
function checkImportMetaProperty(node) {
|
|
if (moduleKind === 100 /* Node16 */ || moduleKind === 199 /* NodeNext */) {
|
|
if (getSourceFileOfNode(node).impliedNodeFormat !== 99 /* ESNext */) {
|
|
error(node, Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
|
|
}
|
|
} else if (moduleKind < 6 /* ES2020 */ && moduleKind !== 4 /* System */) {
|
|
error(node, Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext);
|
|
}
|
|
const file = getSourceFileOfNode(node);
|
|
Debug.assert(!!(file.flags & 4194304 /* PossiblyContainsImportMeta */), "Containing file is missing import meta node flag.");
|
|
return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
|
|
}
|
|
function getTypeOfParameter(symbol) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
if (strictNullChecks) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && hasInitializer(declaration)) {
|
|
return getOptionalType(type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function getTupleElementLabel(d) {
|
|
Debug.assert(isIdentifier(d.name));
|
|
return d.name.escapedText;
|
|
}
|
|
function getParameterNameAtPosition(signature, pos, overrideRestType) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
return signature.parameters[pos].escapedName;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
const restType = overrideRestType || getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index;
|
|
}
|
|
return restParameter.escapedName;
|
|
}
|
|
function getParameterIdentifierNameAtPosition(signature, pos) {
|
|
var _a2;
|
|
if (((_a2 = signature.declaration) == null ? void 0 : _a2.kind) === 320 /* JSDocFunctionType */) {
|
|
return void 0;
|
|
}
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
const param = signature.parameters[pos];
|
|
return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : void 0;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
if (!isParameterDeclarationWithIdentifierName(restParameter)) {
|
|
return void 0;
|
|
}
|
|
const restType = getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
const associatedName = associatedNames == null ? void 0 : associatedNames[index];
|
|
const isRestTupleElement = !!(associatedName == null ? void 0 : associatedName.dotDotDotToken);
|
|
return associatedName ? [
|
|
getTupleElementLabel(associatedName),
|
|
isRestTupleElement
|
|
] : void 0;
|
|
}
|
|
if (pos === paramCount) {
|
|
return [restParameter.escapedName, true];
|
|
}
|
|
return void 0;
|
|
}
|
|
function isParameterDeclarationWithIdentifierName(symbol) {
|
|
return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name);
|
|
}
|
|
function isValidDeclarationForTupleLabel(d) {
|
|
return d.kind === 199 /* NamedTupleMember */ || isParameter(d) && d.name && isIdentifier(d.name);
|
|
}
|
|
function getNameableDeclarationAtPosition(signature, pos) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
const decl = signature.parameters[pos].valueDeclaration;
|
|
return decl && isValidDeclarationForTupleLabel(decl) ? decl : void 0;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
const restType = getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
return associatedNames && associatedNames[index];
|
|
}
|
|
return restParameter.valueDeclaration && isValidDeclarationForTupleLabel(restParameter.valueDeclaration) ? restParameter.valueDeclaration : void 0;
|
|
}
|
|
function getTypeAtPosition(signature, pos) {
|
|
return tryGetTypeAtPosition(signature, pos) || anyType;
|
|
}
|
|
function tryGetTypeAtPosition(signature, pos) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
return getTypeOfParameter(signature.parameters[pos]);
|
|
}
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[paramCount]);
|
|
const index = pos - paramCount;
|
|
if (!isTupleType(restType) || restType.target.hasRestElement || index < restType.target.fixedLength) {
|
|
return getIndexedAccessType(restType, getNumberLiteralType(index));
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getRestTypeAtPosition(source, pos) {
|
|
const parameterCount = getParameterCount(source);
|
|
const minArgumentCount = getMinArgumentCount(source);
|
|
const restType = getEffectiveRestType(source);
|
|
if (restType && pos >= parameterCount - 1) {
|
|
return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
|
|
}
|
|
const types = [];
|
|
const flags = [];
|
|
const names = [];
|
|
for (let i = pos; i < parameterCount; i++) {
|
|
if (!restType || i < parameterCount - 1) {
|
|
types.push(getTypeAtPosition(source, i));
|
|
flags.push(i < minArgumentCount ? 1 /* Required */ : 2 /* Optional */);
|
|
} else {
|
|
types.push(restType);
|
|
flags.push(8 /* Variadic */);
|
|
}
|
|
const name = getNameableDeclarationAtPosition(source, i);
|
|
if (name) {
|
|
names.push(name);
|
|
}
|
|
}
|
|
return createTupleType(types, flags, false, length(names) === length(types) ? names : void 0);
|
|
}
|
|
function getParameterCount(signature) {
|
|
const length2 = signature.parameters.length;
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[length2 - 1]);
|
|
if (isTupleType(restType)) {
|
|
return length2 + restType.target.fixedLength - (restType.target.hasRestElement ? 0 : 1);
|
|
}
|
|
}
|
|
return length2;
|
|
}
|
|
function getMinArgumentCount(signature, flags) {
|
|
const strongArityForUntypedJS = flags & 1 /* StrongArityForUntypedJS */;
|
|
const voidIsNonOptional = flags & 2 /* VoidIsNonOptional */;
|
|
if (voidIsNonOptional || signature.resolvedMinArgumentCount === void 0) {
|
|
let minArgumentCount;
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
if (isTupleType(restType)) {
|
|
const firstOptionalIndex = findIndex(restType.target.elementFlags, (f) => !(f & 1 /* Required */));
|
|
const requiredCount = firstOptionalIndex < 0 ? restType.target.fixedLength : firstOptionalIndex;
|
|
if (requiredCount > 0) {
|
|
minArgumentCount = signature.parameters.length - 1 + requiredCount;
|
|
}
|
|
}
|
|
}
|
|
if (minArgumentCount === void 0) {
|
|
if (!strongArityForUntypedJS && signature.flags & 32 /* IsUntypedSignatureInJSFile */) {
|
|
return 0;
|
|
}
|
|
minArgumentCount = signature.minArgumentCount;
|
|
}
|
|
if (voidIsNonOptional) {
|
|
return minArgumentCount;
|
|
}
|
|
for (let i = minArgumentCount - 1; i >= 0; i--) {
|
|
const type = getTypeAtPosition(signature, i);
|
|
if (filterType(type, acceptsVoid).flags & 131072 /* Never */) {
|
|
break;
|
|
}
|
|
minArgumentCount = i;
|
|
}
|
|
signature.resolvedMinArgumentCount = minArgumentCount;
|
|
}
|
|
return signature.resolvedMinArgumentCount;
|
|
}
|
|
function hasEffectiveRestParameter(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
return !isTupleType(restType) || restType.target.hasRestElement;
|
|
}
|
|
return false;
|
|
}
|
|
function getEffectiveRestType(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
if (!isTupleType(restType)) {
|
|
return restType;
|
|
}
|
|
if (restType.target.hasRestElement) {
|
|
return sliceTupleType(restType, restType.target.fixedLength);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getNonArrayRestType(signature) {
|
|
const restType = getEffectiveRestType(signature);
|
|
return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* Never */) === 0 ? restType : void 0;
|
|
}
|
|
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) {
|
|
const len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
for (let i = 0; i < len; i++) {
|
|
const declaration = signature.parameters[i].valueDeclaration;
|
|
if (declaration.type) {
|
|
const typeNode = 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;
|
|
}
|
|
}
|
|
if (context.thisParameter) {
|
|
const parameter = signature.thisParameter;
|
|
if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) {
|
|
if (!parameter) {
|
|
signature.thisParameter = createSymbolWithType(context.thisParameter, void 0);
|
|
}
|
|
assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter));
|
|
}
|
|
}
|
|
const len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
for (let i = 0; i < len; i++) {
|
|
const parameter = signature.parameters[i];
|
|
if (!getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
|
|
const contextualParameterType = tryGetTypeAtPosition(context, i);
|
|
assignParameterType(parameter, contextualParameterType);
|
|
}
|
|
}
|
|
if (signatureHasRestParameter(signature)) {
|
|
const parameter = last(signature.parameters);
|
|
if (parameter.valueDeclaration ? !getEffectiveTypeAnnotationNode(parameter.valueDeclaration) : !!(getCheckFlags(parameter) & 65536 /* DeferredType */)) {
|
|
const contextualParameterType = getRestTypeAtPosition(context, len);
|
|
assignParameterType(parameter, contextualParameterType);
|
|
}
|
|
}
|
|
}
|
|
function assignNonContextualParameterTypes(signature) {
|
|
if (signature.thisParameter) {
|
|
assignParameterType(signature.thisParameter);
|
|
}
|
|
for (const parameter of signature.parameters) {
|
|
assignParameterType(parameter);
|
|
}
|
|
}
|
|
function assignParameterType(parameter, type) {
|
|
const links = getSymbolLinks(parameter);
|
|
if (!links.type) {
|
|
const declaration = parameter.valueDeclaration;
|
|
links.type = type || (declaration ? getWidenedTypeForVariableLikeDeclaration(declaration, true) : getTypeOfSymbol(parameter));
|
|
if (declaration && declaration.name.kind !== 79 /* Identifier */) {
|
|
if (links.type === unknownType) {
|
|
links.type = getTypeFromBindingPattern(declaration.name);
|
|
}
|
|
assignBindingElementTypes(declaration.name, links.type);
|
|
}
|
|
} else if (type) {
|
|
Debug.assertEqual(links.type, type, "Parameter symbol already has a cached type which differs from newly assigned type");
|
|
}
|
|
}
|
|
function assignBindingElementTypes(pattern, parentType) {
|
|
for (const element of pattern.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
const type = getBindingElementTypeFromParentType(element, parentType);
|
|
if (element.name.kind === 79 /* Identifier */) {
|
|
getSymbolLinks(getSymbolOfNode(element)).type = type;
|
|
} else {
|
|
assignBindingElementTypes(element.name, type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createPromiseType(promisedType) {
|
|
const globalPromiseType = getGlobalPromiseType(true);
|
|
if (globalPromiseType !== emptyGenericType) {
|
|
promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType;
|
|
return createTypeReference(globalPromiseType, [promisedType]);
|
|
}
|
|
return unknownType;
|
|
}
|
|
function createPromiseLikeType(promisedType) {
|
|
const globalPromiseLikeType = getGlobalPromiseLikeType(true);
|
|
if (globalPromiseLikeType !== emptyGenericType) {
|
|
promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType;
|
|
return createTypeReference(globalPromiseLikeType, [promisedType]);
|
|
}
|
|
return unknownType;
|
|
}
|
|
function createPromiseReturnType(func, promisedType) {
|
|
const promiseType = createPromiseType(promisedType);
|
|
if (promiseType === unknownType) {
|
|
error(func, isImportCall(func) ? Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option : 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(true)) {
|
|
error(func, isImportCall(func) ? 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 : 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) {
|
|
const symbol = createSymbol(0 /* None */, "NewTargetExpression");
|
|
const targetPropertySymbol = createSymbol(4 /* Property */, "target", 8 /* Readonly */);
|
|
targetPropertySymbol.parent = symbol;
|
|
targetPropertySymbol.type = targetType;
|
|
const members = createSymbolTable([targetPropertySymbol]);
|
|
symbol.members = members;
|
|
return createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
function getReturnTypeFromBody(func, checkMode) {
|
|
if (!func.body) {
|
|
return errorType;
|
|
}
|
|
const functionFlags = getFunctionFlags(func);
|
|
const isAsync = (functionFlags & 2 /* Async */) !== 0;
|
|
const isGenerator = (functionFlags & 1 /* Generator */) !== 0;
|
|
let returnType;
|
|
let yieldType;
|
|
let nextType;
|
|
let fallbackReturnType = voidType;
|
|
if (func.body.kind !== 238 /* Block */) {
|
|
returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
|
|
if (isAsync) {
|
|
returnType = unwrapAwaitedType(checkAwaitedType(returnType, false, func, 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) {
|
|
const returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode);
|
|
if (!returnTypes) {
|
|
fallbackReturnType = neverType;
|
|
} else if (returnTypes.length > 0) {
|
|
returnType = getUnionType(returnTypes, 2 /* Subtype */);
|
|
}
|
|
const { yieldTypes, nextTypes } = checkAndAggregateYieldOperandTypes(func, checkMode);
|
|
yieldType = some(yieldTypes) ? getUnionType(yieldTypes, 2 /* Subtype */) : void 0;
|
|
nextType = some(nextTypes) ? getIntersectionType(nextTypes) : void 0;
|
|
} else {
|
|
const types = checkAndAggregateReturnExpressionTypes(func, checkMode);
|
|
if (!types) {
|
|
return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, neverType) : neverType;
|
|
}
|
|
if (types.length === 0) {
|
|
return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, voidType) : voidType;
|
|
}
|
|
returnType = getUnionType(types, 2 /* Subtype */);
|
|
}
|
|
if (returnType || yieldType || nextType) {
|
|
if (yieldType)
|
|
reportErrorsFromWidening(func, yieldType, 3 /* GeneratorYield */);
|
|
if (returnType)
|
|
reportErrorsFromWidening(func, returnType, 1 /* FunctionReturn */);
|
|
if (nextType)
|
|
reportErrorsFromWidening(func, nextType, 2 /* GeneratorNext */);
|
|
if (returnType && isUnitType(returnType) || yieldType && isUnitType(yieldType) || nextType && isUnitType(nextType)) {
|
|
const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
|
|
const contextualType = !contextualSignature ? void 0 : contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? void 0 : returnType : instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, void 0);
|
|
if (isGenerator) {
|
|
yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* Yield */, isAsync);
|
|
returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* Return */, isAsync);
|
|
nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2 /* 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 /* Next */, func) || unknownType,
|
|
isAsync
|
|
);
|
|
} else {
|
|
return isAsync ? createPromiseType(returnType || fallbackReturnType) : returnType || fallbackReturnType;
|
|
}
|
|
}
|
|
function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) {
|
|
const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
|
|
const globalGeneratorType = resolver.getGlobalGeneratorType(false);
|
|
yieldType = resolver.resolveIterationType(yieldType, void 0) || unknownType;
|
|
returnType = resolver.resolveIterationType(returnType, void 0) || unknownType;
|
|
nextType = resolver.resolveIterationType(nextType, void 0) || unknownType;
|
|
if (globalGeneratorType === emptyGenericType) {
|
|
const globalType = resolver.getGlobalIterableIteratorType(false);
|
|
const iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : void 0;
|
|
const iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType;
|
|
const iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType;
|
|
if (isTypeAssignableTo(returnType, iterableIteratorReturnType) && isTypeAssignableTo(iterableIteratorNextType, nextType)) {
|
|
if (globalType !== emptyGenericType) {
|
|
return createTypeFromGenericGlobalType(globalType, [yieldType]);
|
|
}
|
|
resolver.getGlobalIterableIteratorType(true);
|
|
return emptyObjectType;
|
|
}
|
|
resolver.getGlobalGeneratorType(true);
|
|
return emptyObjectType;
|
|
}
|
|
return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]);
|
|
}
|
|
function checkAndAggregateYieldOperandTypes(func, checkMode) {
|
|
const yieldTypes = [];
|
|
const nextTypes = [];
|
|
const isAsync = (getFunctionFlags(func) & 2 /* Async */) !== 0;
|
|
forEachYieldExpression(func.body, (yieldExpression) => {
|
|
const yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
|
|
pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
|
|
let nextType;
|
|
if (yieldExpression.asteriskToken) {
|
|
const iterationTypes = getIterationTypesOfIterable(
|
|
yieldExpressionType,
|
|
isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */,
|
|
yieldExpression.expression
|
|
);
|
|
nextType = iterationTypes && iterationTypes.nextType;
|
|
} else {
|
|
nextType = getContextualType(yieldExpression, void 0);
|
|
}
|
|
if (nextType)
|
|
pushIfUnique(nextTypes, nextType);
|
|
});
|
|
return { yieldTypes, nextTypes };
|
|
}
|
|
function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) {
|
|
const errorNode = node.expression || node;
|
|
const yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */, expressionType, sentType, errorNode) : expressionType;
|
|
return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken ? Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member : Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
}
|
|
function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) {
|
|
let facts = 0 /* None */;
|
|
for (let i = 0; i < witnesses.length; i++) {
|
|
const witness = i < start || i >= end ? witnesses[i] : void 0;
|
|
facts |= witness !== void 0 ? typeofNEFacts.get(witness) || 32768 /* TypeofNEHostObject */ : 0;
|
|
}
|
|
return facts;
|
|
}
|
|
function isExhaustiveSwitchStatement(node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.isExhaustive === void 0) {
|
|
links.isExhaustive = 0;
|
|
const exhaustive = computeExhaustiveSwitchStatement(node);
|
|
if (links.isExhaustive === 0) {
|
|
links.isExhaustive = exhaustive;
|
|
}
|
|
} else if (links.isExhaustive === 0) {
|
|
links.isExhaustive = false;
|
|
}
|
|
return links.isExhaustive;
|
|
}
|
|
function computeExhaustiveSwitchStatement(node) {
|
|
if (node.expression.kind === 218 /* TypeOfExpression */) {
|
|
const witnesses = getSwitchClauseTypeOfWitnesses(node);
|
|
if (!witnesses) {
|
|
return false;
|
|
}
|
|
const operandConstraint = getBaseConstraintOrType(checkExpressionCached(node.expression.expression));
|
|
const notEqualFacts = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
|
|
if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
|
|
return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
|
|
}
|
|
return !someType(operandConstraint, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
|
|
}
|
|
const type = checkExpressionCached(node.expression);
|
|
if (!isLiteralType(type)) {
|
|
return false;
|
|
}
|
|
const switchTypes = getSwitchClauseTypes(node);
|
|
if (!switchTypes.length || some(switchTypes, isNeitherUnitTypeNorNever)) {
|
|
return false;
|
|
}
|
|
return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes);
|
|
}
|
|
function functionHasImplicitReturn(func) {
|
|
return func.endFlowNode && isReachableFlowNode(func.endFlowNode);
|
|
}
|
|
function checkAndAggregateReturnExpressionTypes(func, checkMode) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
const aggregatedTypes = [];
|
|
let hasReturnWithNoExpression = functionHasImplicitReturn(func);
|
|
let hasReturnOfTypeNever = false;
|
|
forEachReturnStatement(func.body, (returnStatement) => {
|
|
const expr = returnStatement.expression;
|
|
if (expr) {
|
|
let type = checkExpressionCached(expr, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
|
|
if (functionFlags & 2 /* Async */) {
|
|
type = unwrapAwaitedType(checkAwaitedType(type, false, func, 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 /* Never */) {
|
|
hasReturnOfTypeNever = true;
|
|
}
|
|
pushIfUnique(aggregatedTypes, type);
|
|
} else {
|
|
hasReturnWithNoExpression = true;
|
|
}
|
|
});
|
|
if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) {
|
|
return void 0;
|
|
}
|
|
if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression && !(isJSConstructor(func) && aggregatedTypes.some((t) => t.symbol === func.symbol))) {
|
|
pushIfUnique(aggregatedTypes, undefinedType);
|
|
}
|
|
return aggregatedTypes;
|
|
}
|
|
function mayReturnNever(func) {
|
|
switch (func.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
return func.parent.kind === 207 /* ObjectLiteralExpression */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
|
|
addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
|
|
return;
|
|
function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() {
|
|
const functionFlags = getFunctionFlags(func);
|
|
const type = returnType && unwrapReturnType(returnType, functionFlags);
|
|
if (type && maybeTypeOfKind(type, 1 /* Any */ | 16384 /* Void */)) {
|
|
return;
|
|
}
|
|
if (func.kind === 170 /* MethodSignature */ || nodeIsMissing(func.body) || func.body.kind !== 238 /* Block */ || !functionHasImplicitReturn(func)) {
|
|
return;
|
|
}
|
|
const hasExplicitReturn = func.flags & 512 /* HasExplicitReturn */;
|
|
const errorNode = getEffectiveReturnTypeNode(func) || func;
|
|
if (type && type.flags & 131072 /* Never */) {
|
|
error(errorNode, Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
|
|
} else if (type && !hasExplicitReturn) {
|
|
error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
|
|
} else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
|
|
error(errorNode, Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
|
|
} else if (compilerOptions.noImplicitReturns) {
|
|
if (!type) {
|
|
if (!hasExplicitReturn) {
|
|
return;
|
|
}
|
|
const inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
|
|
if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
|
|
return;
|
|
}
|
|
}
|
|
error(errorNode, Diagnostics.Not_all_code_paths_return_a_value);
|
|
}
|
|
}
|
|
}
|
|
function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
checkNodeDeferred(node);
|
|
if (isFunctionExpression(node)) {
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
if (checkMode && checkMode & 4 /* SkipContextSensitive */ && isContextSensitive(node)) {
|
|
if (!getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) {
|
|
const contextualSignature = getContextualSignature(node);
|
|
if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) {
|
|
const links = getNodeLinks(node);
|
|
if (links.contextFreeType) {
|
|
return links.contextFreeType;
|
|
}
|
|
const returnType = getReturnTypeFromBody(node, checkMode);
|
|
const returnOnlySignature = createSignature(void 0, void 0, void 0, emptyArray, returnType, void 0, 0, 0 /* None */);
|
|
const returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], emptyArray, emptyArray);
|
|
returnOnlyType.objectFlags |= 262144 /* NonInferrableType */;
|
|
return links.contextFreeType = returnOnlyType;
|
|
}
|
|
}
|
|
return anyFunctionType;
|
|
}
|
|
const hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
|
|
if (!hasGrammarError && node.kind === 215 /* FunctionExpression */) {
|
|
checkGrammarForGenerator(node);
|
|
}
|
|
contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
return getTypeOfSymbol(getSymbolOfNode(node));
|
|
}
|
|
function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
|
|
const links = getNodeLinks(node);
|
|
if (!(links.flags & 64 /* ContextChecked */)) {
|
|
const contextualSignature = getContextualSignature(node);
|
|
if (!(links.flags & 64 /* ContextChecked */)) {
|
|
links.flags |= 64 /* ContextChecked */;
|
|
const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* Call */));
|
|
if (!signature) {
|
|
return;
|
|
}
|
|
if (isContextSensitive(node)) {
|
|
if (contextualSignature) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
let instantiatedContextualSignature;
|
|
if (checkMode && checkMode & 2 /* Inferential */) {
|
|
inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
|
|
const restType = getEffectiveRestType(contextualSignature);
|
|
if (restType && restType.flags & 262144 /* TypeParameter */) {
|
|
instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
|
|
}
|
|
}
|
|
instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
|
|
assignContextualParameterTypes(signature, instantiatedContextualSignature);
|
|
} else {
|
|
assignNonContextualParameterTypes(signature);
|
|
}
|
|
}
|
|
if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) {
|
|
const returnType = getReturnTypeFromBody(node, checkMode);
|
|
if (!signature.resolvedReturnType) {
|
|
signature.resolvedReturnType = returnType;
|
|
}
|
|
}
|
|
checkSignatureDeclaration(node);
|
|
}
|
|
}
|
|
}
|
|
function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
const functionFlags = getFunctionFlags(node);
|
|
const returnType = getReturnTypeFromAnnotation(node);
|
|
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
|
|
if (node.body) {
|
|
if (!getEffectiveReturnTypeNode(node)) {
|
|
getReturnTypeOfSignature(getSignatureFromDeclaration(node));
|
|
}
|
|
if (node.body.kind === 238 /* Block */) {
|
|
checkSourceElement(node.body);
|
|
} else {
|
|
const exprType = checkExpression(node.body);
|
|
const returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
|
|
if (returnOrPromisedType) {
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */) {
|
|
const awaitedType = checkAwaitedType(exprType, false, node.body, 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 {
|
|
checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid = false) {
|
|
if (!isTypeAssignableTo(type, numberOrBigIntType)) {
|
|
const awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type);
|
|
errorAndMaybeSuggestAwait(
|
|
operand,
|
|
!!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType),
|
|
diagnostic
|
|
);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function isReadonlyAssignmentDeclaration(d) {
|
|
if (!isCallExpression(d)) {
|
|
return false;
|
|
}
|
|
if (!isBindableObjectDefinePropertyCall(d)) {
|
|
return false;
|
|
}
|
|
const objectLitType = checkExpressionCached(d.arguments[2]);
|
|
const valueType = getTypeOfPropertyOfType(objectLitType, "value");
|
|
if (valueType) {
|
|
const writableProp = getPropertyOfType(objectLitType, "writable");
|
|
const writableType = writableProp && getTypeOfSymbol(writableProp);
|
|
if (!writableType || writableType === falseType || writableType === regularFalseType) {
|
|
return true;
|
|
}
|
|
if (writableProp && writableProp.valueDeclaration && isPropertyAssignment(writableProp.valueDeclaration)) {
|
|
const initializer = writableProp.valueDeclaration.initializer;
|
|
const rawOriginalType = checkExpression(initializer);
|
|
if (rawOriginalType === falseType || rawOriginalType === regularFalseType) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
const setProp = getPropertyOfType(objectLitType, "set");
|
|
return !setProp;
|
|
}
|
|
function isReadonlySymbol(symbol) {
|
|
return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 64 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
|
|
}
|
|
function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
|
|
var _a2, _b;
|
|
if (assignmentKind === 0 /* None */) {
|
|
return false;
|
|
}
|
|
if (isReadonlySymbol(symbol)) {
|
|
if (symbol.flags & 4 /* Property */ && isAccessExpression(expr) && expr.expression.kind === 108 /* ThisKeyword */) {
|
|
const ctor = getContainingFunction(expr);
|
|
if (!(ctor && (ctor.kind === 173 /* Constructor */ || isJSConstructor(ctor)))) {
|
|
return true;
|
|
}
|
|
if (symbol.valueDeclaration) {
|
|
const isAssignmentDeclaration2 = isBinaryExpression(symbol.valueDeclaration);
|
|
const isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent;
|
|
const isLocalParameterProperty = ctor === symbol.valueDeclaration.parent;
|
|
const isLocalThisPropertyAssignment = isAssignmentDeclaration2 && ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) === ctor.parent;
|
|
const isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration2 && ((_b = symbol.parent) == null ? void 0 : _b.valueDeclaration) === ctor;
|
|
const isWriteableSymbol = isLocalPropertyDeclaration || isLocalParameterProperty || isLocalThisPropertyAssignment || isLocalThisPropertyAssignmentConstructorFunction;
|
|
return !isWriteableSymbol;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (isAccessExpression(expr)) {
|
|
const node = skipParentheses(expr.expression);
|
|
if (node.kind === 79 /* Identifier */) {
|
|
const symbol2 = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol2.flags & 2097152 /* Alias */) {
|
|
const declaration = getDeclarationOfAliasSymbol(symbol2);
|
|
return !!declaration && declaration.kind === 271 /* NamespaceImport */;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
|
|
const node = skipOuterExpressions(expr, 6 /* Assertions */ | 1 /* Parentheses */);
|
|
if (node.kind !== 79 /* Identifier */ && !isAccessExpression(node)) {
|
|
error(expr, invalidReferenceMessage);
|
|
return false;
|
|
}
|
|
if (node.flags & 32 /* OptionalChain */) {
|
|
error(expr, invalidOptionalChainMessage);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function checkDeleteExpression(node) {
|
|
checkExpression(node.expression);
|
|
const expr = skipParentheses(node.expression);
|
|
if (!isAccessExpression(expr)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
|
|
return booleanType;
|
|
}
|
|
if (isPropertyAccessExpression(expr) && isPrivateIdentifier(expr.name)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier);
|
|
}
|
|
const links = getNodeLinks(expr);
|
|
const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
|
|
if (symbol) {
|
|
if (isReadonlySymbol(symbol)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
|
|
}
|
|
checkDeleteExpressionMustBeOptional(expr, symbol);
|
|
}
|
|
return booleanType;
|
|
}
|
|
function checkDeleteExpressionMustBeOptional(expr, symbol) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
|
|
error(expr, 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) {
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
error(node, Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block);
|
|
} else if (!(node.flags & 32768 /* AwaitContext */)) {
|
|
if (isInTopLevelContext(node)) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
let span;
|
|
if (!isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
const diagnostic = createFileDiagnostic(
|
|
sourceFile,
|
|
span.start,
|
|
span.length,
|
|
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 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
if (sourceFile.impliedNodeFormat === 1 /* CommonJS */) {
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(
|
|
createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)
|
|
);
|
|
break;
|
|
}
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 4 /* System */:
|
|
if (languageVersion >= 4 /* ES2017 */) {
|
|
break;
|
|
}
|
|
default:
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(
|
|
createFileDiagnostic(
|
|
sourceFile,
|
|
span.start,
|
|
span.length,
|
|
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 {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
const diagnostic = createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
|
|
if (container && container.kind !== 173 /* Constructor */ && (getFunctionFlags(container) & 2 /* Async */) === 0) {
|
|
const relatedInfo = createDiagnosticForNode(container, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
|
|
addRelatedInfo(diagnostic, relatedInfo);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
if (isInParameterInitializerBeforeContainingFunction(node)) {
|
|
error(node, Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
|
|
}
|
|
}
|
|
function checkAwaitExpression(node) {
|
|
addLazyDiagnostic(() => checkAwaitExpressionGrammar(node));
|
|
const operandType = checkExpression(node.expression);
|
|
const awaitedType = checkAwaitedType(operandType, true, node, 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 /* AnyOrUnknown */)) {
|
|
addErrorOrSuggestion(false, createDiagnosticForNode(node, Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
|
|
}
|
|
return awaitedType;
|
|
}
|
|
function checkPrefixUnaryExpression(node) {
|
|
const operandType = checkExpression(node.operand);
|
|
if (operandType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
switch (node.operand.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
switch (node.operator) {
|
|
case 40 /* MinusToken */:
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(-node.operand.text));
|
|
case 39 /* PlusToken */:
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(+node.operand.text));
|
|
}
|
|
break;
|
|
case 9 /* BigIntLiteral */:
|
|
if (node.operator === 40 /* MinusToken */) {
|
|
return getFreshTypeOfLiteralType(getBigIntLiteralType({
|
|
negative: true,
|
|
base10Value: parsePseudoBigInt(node.operand.text)
|
|
}));
|
|
}
|
|
}
|
|
switch (node.operator) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
checkNonNullType(operandType, node.operand);
|
|
if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* ESSymbolLike */)) {
|
|
error(node.operand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(node.operator));
|
|
}
|
|
if (node.operator === 39 /* PlusToken */) {
|
|
if (maybeTypeOfKindConsideringBaseConstraint(operandType, 2112 /* BigIntLike */)) {
|
|
error(node.operand, Diagnostics.Operator_0_cannot_be_applied_to_type_1, tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType)));
|
|
}
|
|
return numberType;
|
|
}
|
|
return getUnaryResultType(operandType);
|
|
case 53 /* ExclamationToken */:
|
|
checkTruthinessExpression(node.operand);
|
|
const facts = getTypeFacts(operandType) & (4194304 /* Truthy */ | 8388608 /* Falsy */);
|
|
return facts === 4194304 /* Truthy */ ? falseType : facts === 8388608 /* Falsy */ ? trueType : booleanType;
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
const ok = checkArithmeticOperandType(
|
|
node.operand,
|
|
checkNonNullType(operandType, node.operand),
|
|
Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type
|
|
);
|
|
if (ok) {
|
|
checkReferenceExpression(
|
|
node.operand,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access
|
|
);
|
|
}
|
|
return getUnaryResultType(operandType);
|
|
}
|
|
return errorType;
|
|
}
|
|
function checkPostfixUnaryExpression(node) {
|
|
const operandType = checkExpression(node.operand);
|
|
if (operandType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
const ok = checkArithmeticOperandType(
|
|
node.operand,
|
|
checkNonNullType(operandType, node.operand),
|
|
Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type
|
|
);
|
|
if (ok) {
|
|
checkReferenceExpression(
|
|
node.operand,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access,
|
|
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 /* BigIntLike */)) {
|
|
return isTypeAssignableToKind(operandType, 3 /* AnyOrUnknown */) || maybeTypeOfKind(operandType, 296 /* NumberLike */) ? numberOrBigIntType : bigintType;
|
|
}
|
|
return numberType;
|
|
}
|
|
function maybeTypeOfKindConsideringBaseConstraint(type, kind) {
|
|
if (maybeTypeOfKind(type, kind)) {
|
|
return true;
|
|
}
|
|
const baseConstraint = getBaseConstraintOrType(type);
|
|
return !!baseConstraint && maybeTypeOfKind(baseConstraint, kind);
|
|
}
|
|
function maybeTypeOfKind(type, kind) {
|
|
if (type.flags & kind) {
|
|
return true;
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
const types = type.types;
|
|
for (const t of types) {
|
|
if (maybeTypeOfKind(t, kind)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeAssignableToKind(source, kind, strict) {
|
|
if (source.flags & kind) {
|
|
return true;
|
|
}
|
|
if (strict && source.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */)) {
|
|
return false;
|
|
}
|
|
return !!(kind & 296 /* NumberLike */) && isTypeAssignableTo(source, numberType) || !!(kind & 2112 /* BigIntLike */) && isTypeAssignableTo(source, bigintType) || !!(kind & 402653316 /* StringLike */) && isTypeAssignableTo(source, stringType) || !!(kind & 528 /* BooleanLike */) && isTypeAssignableTo(source, booleanType) || !!(kind & 16384 /* Void */) && isTypeAssignableTo(source, voidType) || !!(kind & 131072 /* Never */) && isTypeAssignableTo(source, neverType) || !!(kind & 65536 /* Null */) && isTypeAssignableTo(source, nullType) || !!(kind & 32768 /* Undefined */) && isTypeAssignableTo(source, undefinedType) || !!(kind & 4096 /* ESSymbol */) && isTypeAssignableTo(source, esSymbolType) || !!(kind & 67108864 /* NonPrimitive */) && isTypeAssignableTo(source, nonPrimitiveType);
|
|
}
|
|
function allTypesAssignableToKind(source, kind, strict) {
|
|
return source.flags & 1048576 /* Union */ ? every(source.types, (subType) => allTypesAssignableToKind(subType, kind, strict)) : isTypeAssignableToKind(source, kind, strict);
|
|
}
|
|
function isConstEnumObjectType(type) {
|
|
return !!(getObjectFlags(type) & 16 /* Anonymous */) && !!type.symbol && isConstEnumSymbol(type.symbol);
|
|
}
|
|
function isConstEnumSymbol(symbol) {
|
|
return (symbol.flags & 128 /* ConstEnum */) !== 0;
|
|
}
|
|
function checkInstanceOfExpression(left, right, leftType, rightType) {
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 131068 /* Primitive */)) {
|
|
error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
|
|
}
|
|
if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures2(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
|
|
error(right, 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, (t) => t === unknownEmptyObjectType || !!(t.flags & 2097152 /* Intersection */) && isEmptyAnonymousObjectType(getBaseConstraintOrType(t)));
|
|
}
|
|
function checkInExpression(left, right, leftType, rightType) {
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (isPrivateIdentifier(left)) {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(left, 2097152 /* ClassPrivateFieldIn */);
|
|
}
|
|
if (!getNodeLinks(left).resolvedSymbol && getContainingClass(left)) {
|
|
const isUncheckedJS = isUncheckedJSSuggestion(left, rightType.symbol, true);
|
|
reportNonexistentProperty(left, rightType, isUncheckedJS);
|
|
}
|
|
} else {
|
|
checkTypeAssignableTo(checkNonNullType(leftType, left), stringNumberSymbolType, left);
|
|
}
|
|
if (checkTypeAssignableTo(checkNonNullType(rightType, right), nonPrimitiveType, right)) {
|
|
if (hasEmptyObjectIntersection(rightType)) {
|
|
error(right, Diagnostics.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator, typeToString(rightType));
|
|
}
|
|
}
|
|
return booleanType;
|
|
}
|
|
function checkObjectLiteralAssignment(node, sourceType, rightIsThis) {
|
|
const properties = node.properties;
|
|
if (strictNullChecks && properties.length === 0) {
|
|
return checkNonNullType(sourceType, node);
|
|
}
|
|
for (let i = 0; i < properties.length; i++) {
|
|
checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis = false) {
|
|
const properties = node.properties;
|
|
const property = properties[propertyIndex];
|
|
if (property.kind === 299 /* PropertyAssignment */ || property.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const name = property.name;
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(exprType)) {
|
|
const text = getPropertyNameFromType(exprType);
|
|
const prop = getPropertyOfType(objectLiteralType, text);
|
|
if (prop) {
|
|
markPropertyAsReferenced(prop, property, rightIsThis);
|
|
checkPropertyAccessibility(property, false, true, objectLiteralType, prop);
|
|
}
|
|
}
|
|
const elementType = getIndexedAccessType(objectLiteralType, exprType, 32 /* ExpressionPosition */, name);
|
|
const type = getFlowTypeOfDestructuring(property, elementType);
|
|
return checkDestructuringAssignment(property.kind === 300 /* ShorthandPropertyAssignment */ ? property : property.initializer, type);
|
|
} else if (property.kind === 301 /* SpreadAssignment */) {
|
|
if (propertyIndex < properties.length - 1) {
|
|
error(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
} else {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(property, 4 /* Rest */);
|
|
}
|
|
const nonRestNames = [];
|
|
if (allProperties) {
|
|
for (const otherProperty of allProperties) {
|
|
if (!isSpreadAssignment(otherProperty)) {
|
|
nonRestNames.push(otherProperty.name);
|
|
}
|
|
}
|
|
}
|
|
const type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
|
|
checkGrammarForDisallowedTrailingComma(allProperties, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
return checkDestructuringAssignment(property.expression, type);
|
|
}
|
|
} else {
|
|
error(property, Diagnostics.Property_assignment_expected);
|
|
}
|
|
}
|
|
function checkArrayLiteralAssignment(node, sourceType, checkMode) {
|
|
const elements = node.elements;
|
|
if (languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 512 /* Read */);
|
|
}
|
|
const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* Destructuring */ | 128 /* PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType;
|
|
let inBoundsType = compilerOptions.noUncheckedIndexedAccess ? void 0 : possiblyOutOfBoundsType;
|
|
for (let i = 0; i < elements.length; i++) {
|
|
let type = possiblyOutOfBoundsType;
|
|
if (node.elements[i].kind === 227 /* SpreadElement */) {
|
|
type = inBoundsType = inBoundsType != null ? inBoundsType : checkIteratedTypeOrElementType(65 /* Destructuring */, sourceType, undefinedType, node) || errorType;
|
|
}
|
|
checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, type, checkMode);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) {
|
|
const elements = node.elements;
|
|
const element = elements[elementIndex];
|
|
if (element.kind !== 229 /* OmittedExpression */) {
|
|
if (element.kind !== 227 /* SpreadElement */) {
|
|
const indexType = getNumberLiteralType(elementIndex);
|
|
if (isArrayLikeType(sourceType)) {
|
|
const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* NoTupleBoundsCheck */ : 0);
|
|
const elementType2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, accessFlags, createSyntheticExpression(element, indexType)) || errorType;
|
|
const assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType2, 524288 /* NEUndefined */) : elementType2;
|
|
const type = getFlowTypeOfDestructuring(element, assignedType);
|
|
return checkDestructuringAssignment(element, type, checkMode);
|
|
}
|
|
return checkDestructuringAssignment(element, elementType, checkMode);
|
|
}
|
|
if (elementIndex < elements.length - 1) {
|
|
error(element, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
} else {
|
|
const restExpression = element.expression;
|
|
if (restExpression.kind === 223 /* BinaryExpression */ && restExpression.operatorToken.kind === 63 /* EqualsToken */) {
|
|
error(restExpression.operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);
|
|
} else {
|
|
checkGrammarForDisallowedTrailingComma(node.elements, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
const type = everyType(sourceType, isTupleType) ? mapType(sourceType, (t) => sliceTupleType(t, elementIndex)) : createArrayType(elementType);
|
|
return checkDestructuringAssignment(restExpression, type, checkMode);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) {
|
|
let target;
|
|
if (exprOrAssignment.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const prop = exprOrAssignment;
|
|
if (prop.objectAssignmentInitializer) {
|
|
if (strictNullChecks && !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
|
|
sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
|
|
}
|
|
checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
|
|
}
|
|
target = exprOrAssignment.name;
|
|
} else {
|
|
target = exprOrAssignment;
|
|
}
|
|
if (target.kind === 223 /* BinaryExpression */ && target.operatorToken.kind === 63 /* EqualsToken */) {
|
|
checkBinaryExpression(target, checkMode);
|
|
target = target.left;
|
|
if (strictNullChecks) {
|
|
sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
|
|
}
|
|
}
|
|
if (target.kind === 207 /* ObjectLiteralExpression */) {
|
|
return checkObjectLiteralAssignment(target, sourceType, rightIsThis);
|
|
}
|
|
if (target.kind === 206 /* ArrayLiteralExpression */) {
|
|
return checkArrayLiteralAssignment(target, sourceType, checkMode);
|
|
}
|
|
return checkReferenceAssignment(target, sourceType, checkMode);
|
|
}
|
|
function checkReferenceAssignment(target, sourceType, checkMode) {
|
|
const targetType = checkExpression(target, checkMode);
|
|
const error2 = target.parent.kind === 301 /* SpreadAssignment */ ? Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access : Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access;
|
|
const optionalError = target.parent.kind === 301 /* SpreadAssignment */ ? Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access : Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access;
|
|
if (checkReferenceExpression(target, error2, optionalError)) {
|
|
checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target);
|
|
}
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
checkExternalEmitHelpers(target.parent, 1048576 /* ClassPrivateFieldSet */);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function isSideEffectFree(node) {
|
|
node = skipParentheses(node);
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 225 /* TemplateExpression */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 281 /* JsxElement */:
|
|
return true;
|
|
case 224 /* ConditionalExpression */:
|
|
return isSideEffectFree(node.whenTrue) && isSideEffectFree(node.whenFalse);
|
|
case 223 /* BinaryExpression */:
|
|
if (isAssignmentOperator(node.operatorToken.kind)) {
|
|
return false;
|
|
}
|
|
return isSideEffectFree(node.left) && isSideEffectFree(node.right);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
switch (node.operator) {
|
|
case 53 /* ExclamationToken */:
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
return true;
|
|
}
|
|
return false;
|
|
case 219 /* VoidExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isTypeEqualityComparableTo(source, target) {
|
|
return (target.flags & 98304 /* Nullable */) !== 0 || isTypeComparableTo(source, target);
|
|
}
|
|
function createCheckBinaryExpression() {
|
|
const trampoline = createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState);
|
|
return (node, checkMode) => {
|
|
const result = trampoline(node, checkMode);
|
|
Debug.assertIsDefined(result);
|
|
return result;
|
|
};
|
|
function onEnter(node, state, checkMode) {
|
|
if (state) {
|
|
state.stackIndex++;
|
|
state.skip = false;
|
|
setLeftType(state, void 0);
|
|
setLastResult(state, void 0);
|
|
} else {
|
|
state = {
|
|
checkMode,
|
|
skip: false,
|
|
stackIndex: 0,
|
|
typeStack: [void 0, void 0]
|
|
};
|
|
}
|
|
if (isInJSFile(node) && getAssignedExpandoInitializer(node)) {
|
|
state.skip = true;
|
|
setLastResult(state, checkExpression(node.right, checkMode));
|
|
return state;
|
|
}
|
|
checkGrammarNullishCoalesceWithLogicalExpression(node);
|
|
const operator = node.operatorToken.kind;
|
|
if (operator === 63 /* EqualsToken */ && (node.left.kind === 207 /* ObjectLiteralExpression */ || node.left.kind === 206 /* ArrayLiteralExpression */)) {
|
|
state.skip = true;
|
|
setLastResult(state, checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 108 /* 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) {
|
|
const leftType = getLastResult(state);
|
|
Debug.assertIsDefined(leftType);
|
|
setLeftType(state, leftType);
|
|
setLastResult(state, void 0);
|
|
const operator = operatorToken.kind;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
|
|
if (operator === 55 /* AmpersandAmpersandToken */) {
|
|
let parent = node.parent;
|
|
while (parent.kind === 214 /* ParenthesizedExpression */ || isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
|
|
parent = parent.parent;
|
|
}
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.left, leftType, isIfStatement(parent) ? parent.thenStatement : void 0);
|
|
}
|
|
checkTruthinessOfType(leftType, node.left);
|
|
}
|
|
}
|
|
}
|
|
function onRight(right, state, _node) {
|
|
if (!state.skip) {
|
|
return maybeCheckExpression(state, right);
|
|
}
|
|
}
|
|
function onExit(node, state) {
|
|
let result;
|
|
if (state.skip) {
|
|
result = getLastResult(state);
|
|
} else {
|
|
const leftType = getLeftType(state);
|
|
Debug.assertIsDefined(leftType);
|
|
const rightType = getLastResult(state);
|
|
Debug.assertIsDefined(rightType);
|
|
result = checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node);
|
|
}
|
|
state.skip = false;
|
|
setLeftType(state, void 0);
|
|
setLastResult(state, void 0);
|
|
state.stackIndex--;
|
|
return result;
|
|
}
|
|
function foldState(state, result, _side) {
|
|
setLastResult(state, result);
|
|
return state;
|
|
}
|
|
function maybeCheckExpression(state, node) {
|
|
if (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) {
|
|
state.typeStack[state.stackIndex + 1] = type;
|
|
}
|
|
}
|
|
function checkGrammarNullishCoalesceWithLogicalExpression(node) {
|
|
const { left, operatorToken, right } = node;
|
|
if (operatorToken.kind === 60 /* QuestionQuestionToken */) {
|
|
if (isBinaryExpression(left) && (left.operatorToken.kind === 56 /* BarBarToken */ || left.operatorToken.kind === 55 /* AmpersandAmpersandToken */)) {
|
|
grammarErrorOnNode(left, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(left.operatorToken.kind), tokenToString(operatorToken.kind));
|
|
}
|
|
if (isBinaryExpression(right) && (right.operatorToken.kind === 56 /* BarBarToken */ || right.operatorToken.kind === 55 /* AmpersandAmpersandToken */)) {
|
|
grammarErrorOnNode(right, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(right.operatorToken.kind), tokenToString(operatorToken.kind));
|
|
}
|
|
}
|
|
}
|
|
function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) {
|
|
const operator = operatorToken.kind;
|
|
if (operator === 63 /* EqualsToken */ && (left.kind === 207 /* ObjectLiteralExpression */ || left.kind === 206 /* ArrayLiteralExpression */)) {
|
|
return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 108 /* ThisKeyword */);
|
|
}
|
|
let leftType;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
|
|
leftType = checkTruthinessExpression(left, checkMode);
|
|
} else {
|
|
leftType = checkExpression(left, checkMode);
|
|
}
|
|
const rightType = checkExpression(right, checkMode);
|
|
return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode);
|
|
}
|
|
function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) {
|
|
const operator = operatorToken.kind;
|
|
switch (operator) {
|
|
case 41 /* AsteriskToken */:
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 44 /* PercentToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 40 /* MinusToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 51 /* BarToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 52 /* CaretToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
leftType = checkNonNullType(leftType, left);
|
|
rightType = checkNonNullType(rightType, right);
|
|
let suggestedOperator;
|
|
if (leftType.flags & 528 /* BooleanLike */ && rightType.flags & 528 /* BooleanLike */ && (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== void 0) {
|
|
error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator));
|
|
return numberType;
|
|
} else {
|
|
const leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
|
|
const rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
|
|
let resultType2;
|
|
if (isTypeAssignableToKind(leftType, 3 /* AnyOrUnknown */) && isTypeAssignableToKind(rightType, 3 /* AnyOrUnknown */) || !(maybeTypeOfKind(leftType, 2112 /* BigIntLike */) || maybeTypeOfKind(rightType, 2112 /* BigIntLike */))) {
|
|
resultType2 = numberType;
|
|
} else if (bothAreBigIntLike(leftType, rightType)) {
|
|
switch (operator) {
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
reportOperatorError();
|
|
break;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
if (languageVersion < 3 /* ES2016 */) {
|
|
error(errorNode, Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later);
|
|
}
|
|
}
|
|
resultType2 = bigintType;
|
|
} else {
|
|
reportOperatorError(bothAreBigIntLike);
|
|
resultType2 = errorType;
|
|
}
|
|
if (leftOk && rightOk) {
|
|
checkAssignmentOperator(resultType2);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 39 /* PlusToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (!isTypeAssignableToKind(leftType, 402653316 /* StringLike */) && !isTypeAssignableToKind(rightType, 402653316 /* StringLike */)) {
|
|
leftType = checkNonNullType(leftType, left);
|
|
rightType = checkNonNullType(rightType, right);
|
|
}
|
|
let resultType;
|
|
if (isTypeAssignableToKind(leftType, 296 /* NumberLike */, true) && isTypeAssignableToKind(rightType, 296 /* NumberLike */, true)) {
|
|
resultType = numberType;
|
|
} else if (isTypeAssignableToKind(leftType, 2112 /* BigIntLike */, true) && isTypeAssignableToKind(rightType, 2112 /* BigIntLike */, true)) {
|
|
resultType = bigintType;
|
|
} else if (isTypeAssignableToKind(leftType, 402653316 /* StringLike */, true) || isTypeAssignableToKind(rightType, 402653316 /* StringLike */, true)) {
|
|
resultType = stringType;
|
|
} else if (isTypeAny(leftType) || isTypeAny(rightType)) {
|
|
resultType = isErrorType(leftType) || isErrorType(rightType) ? errorType : anyType;
|
|
}
|
|
if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
|
|
return resultType;
|
|
}
|
|
if (!resultType) {
|
|
const closeEnoughKind = 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 3 /* AnyOrUnknown */;
|
|
reportOperatorError((left2, right2) => isTypeAssignableToKind(left2, closeEnoughKind) && isTypeAssignableToKind(right2, closeEnoughKind));
|
|
return anyType;
|
|
}
|
|
if (operator === 64 /* PlusEqualsToken */) {
|
|
checkAssignmentOperator(resultType);
|
|
}
|
|
return resultType;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
if (checkForDisallowedESSymbolOperand(operator)) {
|
|
leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left));
|
|
rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right));
|
|
reportOperatorErrorUnless((left2, right2) => isTypeComparableTo(left2, right2) || isTypeComparableTo(right2, left2) || isTypeAssignableTo(left2, numberOrBigIntType) && isTypeAssignableTo(right2, numberOrBigIntType));
|
|
}
|
|
return booleanType;
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
|
|
const eqType = operator === 34 /* EqualsEqualsToken */ || operator === 36 /* EqualsEqualsEqualsToken */;
|
|
error(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
|
|
}
|
|
checkNaNEquality(errorNode, operator, left, right);
|
|
reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
|
|
return booleanType;
|
|
case 102 /* InstanceOfKeyword */:
|
|
return checkInstanceOfExpression(left, right, leftType, rightType);
|
|
case 101 /* InKeyword */:
|
|
return checkInExpression(left, right, leftType, rightType);
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 4194304 /* Truthy */ ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
|
|
if (operator === 76 /* AmpersandAmpersandEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 56 /* BarBarToken */:
|
|
case 75 /* BarBarEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 8388608 /* Falsy */ ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
|
|
if (operator === 75 /* BarBarEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 60 /* QuestionQuestionToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 262144 /* EQUndefinedOrNull */ ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
|
|
if (operator === 77 /* QuestionQuestionEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 63 /* EqualsToken */:
|
|
const declKind = isBinaryExpression(left.parent) ? getAssignmentDeclarationKind(left.parent) : 0 /* None */;
|
|
checkAssignmentDeclaration(declKind, rightType);
|
|
if (isAssignmentDeclaration2(declKind)) {
|
|
if (!(rightType.flags & 524288 /* Object */) || declKind !== 2 /* ModuleExports */ && declKind !== 6 /* Prototype */ && !isEmptyObjectType(rightType) && !isFunctionObjectType(rightType) && !(getObjectFlags(rightType) & 1 /* Class */)) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return leftType;
|
|
} else {
|
|
checkAssignmentOperator(rightType);
|
|
return getRegularTypeOfObjectLiteral(rightType);
|
|
}
|
|
case 27 /* CommaToken */:
|
|
if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) {
|
|
const sf = getSourceFileOfNode(left);
|
|
const sourceText = sf.text;
|
|
const start = skipTrivia(sourceText, left.pos);
|
|
const isInDiag2657 = sf.parseDiagnostics.some((diag2) => {
|
|
if (diag2.code !== Diagnostics.JSX_expressions_must_have_one_parent_element.code)
|
|
return false;
|
|
return textSpanContainsPosition(diag2, start);
|
|
});
|
|
if (!isInDiag2657)
|
|
error(left, Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects);
|
|
}
|
|
return rightType;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
function bothAreBigIntLike(left2, right2) {
|
|
return isTypeAssignableToKind(left2, 2112 /* BigIntLike */) && isTypeAssignableToKind(right2, 2112 /* BigIntLike */);
|
|
}
|
|
function checkAssignmentDeclaration(kind, rightType2) {
|
|
if (kind === 2 /* ModuleExports */) {
|
|
for (const prop of getPropertiesOfObjectType(rightType2)) {
|
|
const propType = getTypeOfSymbol(prop);
|
|
if (propType.symbol && propType.symbol.flags & 32 /* Class */) {
|
|
const name = prop.escapedName;
|
|
const symbol = resolveName(prop.valueDeclaration, name, 788968 /* Type */, void 0, name, false);
|
|
if ((symbol == null ? void 0 : symbol.declarations) && symbol.declarations.some(isJSDocTypedefTag)) {
|
|
addDuplicateDeclarationErrorsForSymbols(symbol, Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(name), prop);
|
|
addDuplicateDeclarationErrorsForSymbols(prop, Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(name), symbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isEvalNode(node) {
|
|
return node.kind === 79 /* Identifier */ && node.escapedText === "eval";
|
|
}
|
|
function checkForDisallowedESSymbolOperand(operator2) {
|
|
const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
|
|
if (offendingSymbolOperand) {
|
|
error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator2));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getSuggestedBooleanOperator(operator2) {
|
|
switch (operator2) {
|
|
case 51 /* BarToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
return 56 /* BarBarToken */;
|
|
case 52 /* CaretToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
return 37 /* ExclamationEqualsEqualsToken */;
|
|
case 50 /* AmpersandToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
return 55 /* AmpersandAmpersandToken */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkAssignmentOperator(valueType) {
|
|
if (isAssignmentOperator(operator)) {
|
|
addLazyDiagnostic(checkAssignmentOperatorWorker);
|
|
}
|
|
function checkAssignmentOperatorWorker() {
|
|
if (checkReferenceExpression(
|
|
left,
|
|
Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access
|
|
) && (!isIdentifier(left) || unescapeLeadingUnderscores(left.escapedText) !== "exports")) {
|
|
let headMessage;
|
|
if (exactOptionalPropertyTypes && isPropertyAccessExpression(left) && maybeTypeOfKind(valueType, 32768 /* Undefined */)) {
|
|
const target = getTypeOfPropertyOfType(getTypeOfExpression(left.expression), left.name.escapedText);
|
|
if (isExactOptionalPropertyMismatch(valueType, target)) {
|
|
headMessage = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target;
|
|
}
|
|
}
|
|
checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right, headMessage);
|
|
}
|
|
}
|
|
}
|
|
function isAssignmentDeclaration2(kind) {
|
|
var _a2;
|
|
switch (kind) {
|
|
case 2 /* ModuleExports */:
|
|
return true;
|
|
case 1 /* ExportsProperty */:
|
|
case 5 /* Property */:
|
|
case 6 /* Prototype */:
|
|
case 3 /* PrototypeProperty */:
|
|
case 4 /* ThisProperty */:
|
|
const symbol = getSymbolOfNode(left);
|
|
const init = getAssignedExpandoInitializer(right);
|
|
return !!init && isObjectLiteralExpression(init) && !!((_a2 = symbol == null ? void 0 : symbol.exports) == null ? void 0 : _a2.size);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function reportOperatorErrorUnless(typesAreCompatible) {
|
|
if (!typesAreCompatible(leftType, rightType)) {
|
|
reportOperatorError(typesAreCompatible);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function reportOperatorError(isRelated) {
|
|
let wouldWorkWithAwait = false;
|
|
const errNode = errorNode || operatorToken;
|
|
if (isRelated) {
|
|
const awaitedLeftType = getAwaitedTypeNoAlias(leftType);
|
|
const awaitedRightType = getAwaitedTypeNoAlias(rightType);
|
|
wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType) && !!(awaitedLeftType && awaitedRightType) && isRelated(awaitedLeftType, awaitedRightType);
|
|
}
|
|
let effectiveLeft = leftType;
|
|
let effectiveRight = rightType;
|
|
if (!wouldWorkWithAwait && isRelated) {
|
|
[effectiveLeft, effectiveRight] = getBaseTypesIfUnrelated(leftType, rightType, isRelated);
|
|
}
|
|
const [leftStr, rightStr] = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight);
|
|
if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) {
|
|
errorAndMaybeSuggestAwait(
|
|
errNode,
|
|
wouldWorkWithAwait,
|
|
Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2,
|
|
tokenToString(operatorToken.kind),
|
|
leftStr,
|
|
rightStr
|
|
);
|
|
}
|
|
}
|
|
function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) {
|
|
switch (operatorToken.kind) {
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
return errorAndMaybeSuggestAwait(
|
|
errNode,
|
|
maybeMissingAwait,
|
|
Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap,
|
|
leftStr,
|
|
rightStr
|
|
);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkNaNEquality(errorNode2, operator2, left2, right2) {
|
|
const isLeftNaN = isGlobalNaN(skipParentheses(left2));
|
|
const isRightNaN = isGlobalNaN(skipParentheses(right2));
|
|
if (isLeftNaN || isRightNaN) {
|
|
const err = error(
|
|
errorNode2,
|
|
Diagnostics.This_condition_will_always_return_0,
|
|
tokenToString(operator2 === 36 /* EqualsEqualsEqualsToken */ || operator2 === 34 /* EqualsEqualsToken */ ? 95 /* FalseKeyword */ : 110 /* TrueKeyword */)
|
|
);
|
|
if (isLeftNaN && isRightNaN)
|
|
return;
|
|
const operatorString = operator2 === 37 /* ExclamationEqualsEqualsToken */ || operator2 === 35 /* ExclamationEqualsToken */ ? tokenToString(53 /* ExclamationToken */) : "";
|
|
const location = isLeftNaN ? right2 : left2;
|
|
const expression = skipParentheses(location);
|
|
addRelatedInfo(err, createDiagnosticForNode(
|
|
location,
|
|
Diagnostics.Did_you_mean_0,
|
|
`${operatorString}Number.isNaN(${isEntityNameExpression(expression) ? entityNameToString(expression) : "..."})`
|
|
));
|
|
}
|
|
}
|
|
function isGlobalNaN(expr) {
|
|
if (isIdentifier(expr) && expr.escapedText === "NaN") {
|
|
const globalNaNSymbol = getGlobalNaNSymbol();
|
|
return !!globalNaNSymbol && globalNaNSymbol === getResolvedSymbol(expr);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getBaseTypesIfUnrelated(leftType, rightType, isRelated) {
|
|
let effectiveLeft = leftType;
|
|
let effectiveRight = rightType;
|
|
const leftBase = getBaseTypeOfLiteralType(leftType);
|
|
const rightBase = getBaseTypeOfLiteralType(rightType);
|
|
if (!isRelated(leftBase, rightBase)) {
|
|
effectiveLeft = leftBase;
|
|
effectiveRight = rightBase;
|
|
}
|
|
return [effectiveLeft, effectiveRight];
|
|
}
|
|
function checkYieldExpression(node) {
|
|
addLazyDiagnostic(checkYieldExpressionGrammar);
|
|
const func = getContainingFunction(node);
|
|
if (!func)
|
|
return anyType;
|
|
const functionFlags = getFunctionFlags(func);
|
|
if (!(functionFlags & 1 /* Generator */)) {
|
|
return anyType;
|
|
}
|
|
const isAsync = (functionFlags & 2 /* Async */) !== 0;
|
|
if (node.asteriskToken) {
|
|
if (isAsync && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */);
|
|
}
|
|
if (!isAsync && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 256 /* Values */);
|
|
}
|
|
}
|
|
const returnType = getReturnTypeFromAnnotation(func);
|
|
const iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
|
|
const signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
|
|
const signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
|
|
const resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType;
|
|
const yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType;
|
|
const yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync);
|
|
if (returnType && yieldedType) {
|
|
checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression);
|
|
}
|
|
if (node.asteriskToken) {
|
|
const use = isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */;
|
|
return getIterationTypeOfIterable(use, 1 /* Return */, yieldExpressionType, node.expression) || anyType;
|
|
} else if (returnType) {
|
|
return getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, isAsync) || anyType;
|
|
}
|
|
let type = getContextualIterationType(2 /* Next */, func);
|
|
if (!type) {
|
|
type = anyType;
|
|
addLazyDiagnostic(() => {
|
|
if (noImplicitAny && !expressionResultIsUnused(node)) {
|
|
const contextualType = getContextualType(node, void 0);
|
|
if (!contextualType || isTypeAny(contextualType)) {
|
|
error(node, 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 /* YieldContext */)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
|
|
}
|
|
if (isInParameterInitializerBeforeContainingFunction(node)) {
|
|
error(node, Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
|
|
}
|
|
}
|
|
}
|
|
function checkConditionalExpression(node, checkMode) {
|
|
const type = checkTruthinessExpression(node.condition);
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.condition, type, node.whenTrue);
|
|
const type1 = checkExpression(node.whenTrue, checkMode);
|
|
const type2 = checkExpression(node.whenFalse, checkMode);
|
|
return getUnionType([type1, type2], 2 /* Subtype */);
|
|
}
|
|
function isTemplateLiteralContext(node) {
|
|
const parent = node.parent;
|
|
return isParenthesizedExpression(parent) && isTemplateLiteralContext(parent) || isElementAccessExpression(parent) && parent.argumentExpression === node;
|
|
}
|
|
function checkTemplateExpression(node) {
|
|
const texts = [node.head.text];
|
|
const types = [];
|
|
for (const span of node.templateSpans) {
|
|
const type = checkExpression(span.expression);
|
|
if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* ESSymbolLike */)) {
|
|
error(span.expression, 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, void 0) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
|
|
}
|
|
function isTemplateLiteralContextualType(type) {
|
|
return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
|
|
}
|
|
function getContextNode(node) {
|
|
if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
|
|
return node.parent.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
|
|
const context = getContextNode(node);
|
|
const saveContextualType = context.contextualType;
|
|
const saveInferenceContext = context.inferenceContext;
|
|
try {
|
|
context.contextualType = contextualType;
|
|
context.inferenceContext = inferenceContext;
|
|
const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
|
|
if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
|
|
inferenceContext.intraExpressionInferenceSites = void 0;
|
|
}
|
|
const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, void 0)) ? getRegularTypeOfLiteralType(type) : type;
|
|
return result;
|
|
} finally {
|
|
context.contextualType = saveContextualType;
|
|
context.inferenceContext = saveInferenceContext;
|
|
}
|
|
}
|
|
function checkExpressionCached(node, checkMode) {
|
|
if (checkMode) {
|
|
return checkExpression(node, checkMode);
|
|
}
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const saveFlowLoopStart = flowLoopStart;
|
|
const saveFlowTypeCache = flowTypeCache;
|
|
flowLoopStart = flowLoopCount;
|
|
flowTypeCache = void 0;
|
|
links.resolvedType = checkExpression(node, checkMode);
|
|
flowTypeCache = saveFlowTypeCache;
|
|
flowLoopStart = saveFlowLoopStart;
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isTypeAssertion(node) {
|
|
node = skipParentheses(node, true);
|
|
return node.kind === 213 /* TypeAssertionExpression */ || node.kind === 231 /* AsExpression */ || isJSDocTypeAssertion(node);
|
|
}
|
|
function checkDeclarationInitializer(declaration, checkMode, contextualType) {
|
|
const initializer = getEffectiveInitializer(declaration);
|
|
const type = getQuickTypeOfExpression(initializer) || (contextualType ? checkExpressionWithContextualType(initializer, contextualType, void 0, checkMode || 0 /* Normal */) : checkExpressionCached(initializer, checkMode));
|
|
return isParameter(declaration) && declaration.name.kind === 204 /* ArrayBindingPattern */ && isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ? padTupleType(type, declaration.name) : type;
|
|
}
|
|
function padTupleType(type, pattern) {
|
|
const patternElements = pattern.elements;
|
|
const elementTypes = getTypeArguments(type).slice();
|
|
const elementFlags = type.target.elementFlags.slice();
|
|
for (let i = getTypeReferenceArity(type); i < patternElements.length; i++) {
|
|
const e = patternElements[i];
|
|
if (i < patternElements.length - 1 || !(e.kind === 205 /* BindingElement */ && e.dotDotDotToken)) {
|
|
elementTypes.push(!isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, false, false) : anyType);
|
|
elementFlags.push(2 /* Optional */);
|
|
if (!isOmittedExpression(e) && !hasDefaultValue(e)) {
|
|
reportImplicitAny(e, anyType);
|
|
}
|
|
}
|
|
}
|
|
return createTupleType(elementTypes, elementFlags, type.target.readonly);
|
|
}
|
|
function widenTypeInferredFromInitializer(declaration, type) {
|
|
const widened = getCombinedNodeFlags(declaration) & 2 /* Const */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
|
|
if (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 /* UnionOrIntersection */) {
|
|
const types = contextualType.types;
|
|
return some(types, (t) => isLiteralOfContextualType(candidateType, t));
|
|
}
|
|
if (contextualType.flags & 58982400 /* InstantiableNonPrimitive */) {
|
|
const constraint = getBaseConstraintOfType(contextualType) || unknownType;
|
|
return maybeTypeOfKind(constraint, 4 /* String */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || maybeTypeOfKind(constraint, 8 /* Number */) && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || maybeTypeOfKind(constraint, 64 /* BigInt */) && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || maybeTypeOfKind(constraint, 4096 /* ESSymbol */) && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */) || isLiteralOfContextualType(candidateType, constraint);
|
|
}
|
|
return !!(contextualType.flags & (128 /* StringLiteral */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || contextualType.flags & 256 /* NumberLiteral */ && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || contextualType.flags & 2048 /* BigIntLiteral */ && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || contextualType.flags & 512 /* BooleanLiteral */ && maybeTypeOfKind(candidateType, 512 /* BooleanLiteral */) || contextualType.flags & 8192 /* UniqueESSymbol */ && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */));
|
|
}
|
|
return false;
|
|
}
|
|
function isConstContext(node) {
|
|
const parent = node.parent;
|
|
return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
|
|
}
|
|
function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
|
|
const type = checkExpression(node, checkMode, forceTuple);
|
|
return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, void 0) : contextualType, node, void 0));
|
|
}
|
|
function checkPropertyAssignment(node, checkMode) {
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
return checkExpressionForMutableLocation(node.initializer, checkMode);
|
|
}
|
|
function checkObjectLiteralMethod(node, checkMode) {
|
|
checkGrammarMethod(node);
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
const uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
|
|
}
|
|
function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) {
|
|
if (checkMode && checkMode & (2 /* Inferential */ | 8 /* SkipGenericFunctions */)) {
|
|
const callSignature = getSingleSignature(type, 0 /* Call */, true);
|
|
const constructSignature = getSingleSignature(type, 1 /* Construct */, true);
|
|
const signature = callSignature || constructSignature;
|
|
if (signature && signature.typeParameters) {
|
|
const contextualType = getApparentTypeOfContextualType(node, 2 /* NoConstraints */);
|
|
if (contextualType) {
|
|
const contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 /* Call */ : 1 /* Construct */, false);
|
|
if (contextualSignature && !contextualSignature.typeParameters) {
|
|
if (checkMode & 8 /* SkipGenericFunctions */) {
|
|
skippedGenericFunction(node, checkMode);
|
|
return anyFunctionType;
|
|
}
|
|
const context = getInferenceContext(node);
|
|
const returnType = context.signature && getReturnTypeOfSignature(context.signature);
|
|
const returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
|
|
if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
|
|
const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
|
|
const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
|
|
const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
|
|
applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
|
|
inferTypes(inferences, source, target, 0, true);
|
|
});
|
|
if (some(inferences, hasInferenceCandidates)) {
|
|
applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
|
|
inferTypes(inferences, source, target);
|
|
});
|
|
if (!hasOverlappingInferences(context.inferences, inferences)) {
|
|
mergeInferences(context.inferences, inferences);
|
|
context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
|
|
return getOrCreateTypeFromSignature(instantiatedSignature);
|
|
}
|
|
}
|
|
}
|
|
return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function skippedGenericFunction(node, checkMode) {
|
|
if (checkMode & 2 /* Inferential */) {
|
|
const context = getInferenceContext(node);
|
|
context.flags |= 4 /* 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 (let i = 0; i < a.length; i++) {
|
|
if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function mergeInferences(target, source) {
|
|
for (let i = 0; i < target.length; i++) {
|
|
if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
|
|
target[i] = source[i];
|
|
}
|
|
}
|
|
}
|
|
function getUniqueTypeParameters(context, typeParameters) {
|
|
const result = [];
|
|
let oldTypeParameters;
|
|
let newTypeParameters;
|
|
for (const tp of typeParameters) {
|
|
const name = tp.symbol.escapedName;
|
|
if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) {
|
|
const newName = getUniqueTypeParameterName(concatenate(context.inferredTypeParameters, result), name);
|
|
const symbol = createSymbol(262144 /* TypeParameter */, newName);
|
|
const newTypeParameter = createTypeParameter(symbol);
|
|
newTypeParameter.target = tp;
|
|
oldTypeParameters = append(oldTypeParameters, tp);
|
|
newTypeParameters = append(newTypeParameters, newTypeParameter);
|
|
result.push(newTypeParameter);
|
|
} else {
|
|
result.push(tp);
|
|
}
|
|
}
|
|
if (newTypeParameters) {
|
|
const mapper = createTypeMapper(oldTypeParameters, newTypeParameters);
|
|
for (const tp of newTypeParameters) {
|
|
tp.mapper = mapper;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function hasTypeParameterByName(typeParameters, name) {
|
|
return some(typeParameters, (tp) => tp.symbol.escapedName === name);
|
|
}
|
|
function getUniqueTypeParameterName(typeParameters, baseName) {
|
|
let len = baseName.length;
|
|
while (len > 1 && baseName.charCodeAt(len - 1) >= 48 /* _0 */ && baseName.charCodeAt(len - 1) <= 57 /* _9 */)
|
|
len--;
|
|
const s = baseName.slice(0, len);
|
|
for (let index = 1; true; index++) {
|
|
const augmentedName = s + index;
|
|
if (!hasTypeParameterByName(typeParameters, augmentedName)) {
|
|
return augmentedName;
|
|
}
|
|
}
|
|
}
|
|
function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
|
|
const signature = getSingleCallSignature(funcType);
|
|
if (signature && !signature.typeParameters) {
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
}
|
|
function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
|
|
const funcType = checkExpression(expr.expression);
|
|
const nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
|
|
const returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
|
|
return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
|
|
}
|
|
function getTypeOfExpression(node) {
|
|
const quickType = getQuickTypeOfExpression(node);
|
|
if (quickType) {
|
|
return quickType;
|
|
}
|
|
if (node.flags & 134217728 /* TypeCached */ && flowTypeCache) {
|
|
const cachedType = flowTypeCache[getNodeId(node)];
|
|
if (cachedType) {
|
|
return cachedType;
|
|
}
|
|
}
|
|
const startInvocationCount = flowInvocationCount;
|
|
const type = checkExpression(node);
|
|
if (flowInvocationCount !== startInvocationCount) {
|
|
const cache = flowTypeCache || (flowTypeCache = []);
|
|
cache[getNodeId(node)] = type;
|
|
setNodeFlags(node, node.flags | 134217728 /* TypeCached */);
|
|
}
|
|
return type;
|
|
}
|
|
function getQuickTypeOfExpression(node) {
|
|
let expr = skipParentheses(node, true);
|
|
if (isJSDocTypeAssertion(expr)) {
|
|
const type = getJSDocTypeAssertionType(expr);
|
|
if (!isConstTypeReference(type)) {
|
|
return getTypeFromTypeNode(type);
|
|
}
|
|
}
|
|
expr = skipParentheses(node);
|
|
if (isCallExpression(expr) && expr.expression.kind !== 106 /* SuperKeyword */ && !isRequireCall(expr, true) && !isSymbolOrSymbolForCall(expr)) {
|
|
const type = isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
|
|
if (type) {
|
|
return type;
|
|
}
|
|
} else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
|
|
return getTypeFromTypeNode(expr.type);
|
|
} else if (node.kind === 8 /* NumericLiteral */ || node.kind === 10 /* StringLiteral */ || node.kind === 110 /* TrueKeyword */ || node.kind === 95 /* FalseKeyword */) {
|
|
return checkExpression(node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextFreeTypeOfExpression(node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.contextFreeType) {
|
|
return links.contextFreeType;
|
|
}
|
|
const saveContextualType = node.contextualType;
|
|
node.contextualType = anyType;
|
|
try {
|
|
const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
|
|
return type;
|
|
} finally {
|
|
node.contextualType = saveContextualType;
|
|
}
|
|
}
|
|
function checkExpression(node, checkMode, forceTuple) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
|
|
const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
|
|
if (isConstEnumObjectType(type)) {
|
|
checkConstEnumAccess(node, type);
|
|
}
|
|
currentNode = saveCurrentNode;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return type;
|
|
}
|
|
function checkConstEnumAccess(node, type) {
|
|
const ok = node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.expression === node || node.parent.kind === 209 /* ElementAccessExpression */ && node.parent.expression === node || ((node.kind === 79 /* Identifier */ || node.kind === 163 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node) || node.parent.kind === 183 /* TypeQuery */ && node.parent.exprName === node) || node.parent.kind === 278 /* ExportSpecifier */;
|
|
if (!ok) {
|
|
error(node, 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) {
|
|
Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
|
|
const constEnumDeclaration = type.symbol.valueDeclaration;
|
|
if (constEnumDeclaration.flags & 16777216 /* Ambient */) {
|
|
error(node, Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
|
|
}
|
|
}
|
|
}
|
|
function checkParenthesizedExpression(node, checkMode) {
|
|
if (hasJSDocNodes(node) && isJSDocTypeAssertion(node)) {
|
|
const type = getJSDocTypeAssertionType(node);
|
|
return checkAssertionWorker(type, type, node.expression, checkMode);
|
|
}
|
|
return checkExpression(node.expression, checkMode);
|
|
}
|
|
function checkExpressionWorker(node, checkMode, forceTuple) {
|
|
const kind = node.kind;
|
|
if (cancellationToken) {
|
|
switch (kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
switch (kind) {
|
|
case 79 /* Identifier */:
|
|
return checkIdentifier(node, checkMode);
|
|
case 80 /* PrivateIdentifier */:
|
|
return checkPrivateIdentifierExpression(node);
|
|
case 108 /* ThisKeyword */:
|
|
return checkThisExpression(node);
|
|
case 106 /* SuperKeyword */:
|
|
return checkSuperExpression(node);
|
|
case 104 /* NullKeyword */:
|
|
return nullWideningType;
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return getFreshTypeOfLiteralType(getStringLiteralType(node.text));
|
|
case 8 /* NumericLiteral */:
|
|
checkGrammarNumericLiteral(node);
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text));
|
|
case 9 /* BigIntLiteral */:
|
|
checkGrammarBigIntLiteral(node);
|
|
return getFreshTypeOfLiteralType(getBigIntLiteralType({
|
|
negative: false,
|
|
base10Value: parsePseudoBigInt(node.text)
|
|
}));
|
|
case 110 /* TrueKeyword */:
|
|
return trueType;
|
|
case 95 /* FalseKeyword */:
|
|
return falseType;
|
|
case 225 /* TemplateExpression */:
|
|
return checkTemplateExpression(node);
|
|
case 13 /* RegularExpressionLiteral */:
|
|
return globalRegExpType;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return checkArrayLiteral(node, checkMode, forceTuple);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return checkObjectLiteral(node, checkMode);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return checkPropertyAccessExpression(node, checkMode);
|
|
case 163 /* QualifiedName */:
|
|
return checkQualifiedName(node, checkMode);
|
|
case 209 /* ElementAccessExpression */:
|
|
return checkIndexedAccess(node, checkMode);
|
|
case 210 /* CallExpression */:
|
|
if (node.expression.kind === 100 /* ImportKeyword */) {
|
|
return checkImportCallExpression(node);
|
|
}
|
|
case 211 /* NewExpression */:
|
|
return checkCallExpression(node, checkMode);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return checkTaggedTemplateExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return checkParenthesizedExpression(node, checkMode);
|
|
case 228 /* ClassExpression */:
|
|
return checkClassExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
case 218 /* TypeOfExpression */:
|
|
return checkTypeOfExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return checkAssertion(node);
|
|
case 232 /* NonNullExpression */:
|
|
return checkNonNullAssertion(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return checkExpressionWithTypeArguments(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return checkSatisfiesExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return checkMetaProperty(node);
|
|
case 217 /* DeleteExpression */:
|
|
return checkDeleteExpression(node);
|
|
case 219 /* VoidExpression */:
|
|
return checkVoidExpression(node);
|
|
case 220 /* AwaitExpression */:
|
|
return checkAwaitExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return checkPrefixUnaryExpression(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return checkPostfixUnaryExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return checkBinaryExpression(node, checkMode);
|
|
case 224 /* ConditionalExpression */:
|
|
return checkConditionalExpression(node, checkMode);
|
|
case 227 /* SpreadElement */:
|
|
return checkSpreadExpression(node, checkMode);
|
|
case 229 /* OmittedExpression */:
|
|
return undefinedWideningType;
|
|
case 226 /* YieldExpression */:
|
|
return checkYieldExpression(node);
|
|
case 234 /* SyntheticExpression */:
|
|
return checkSyntheticExpression(node);
|
|
case 291 /* JsxExpression */:
|
|
return checkJsxExpression(node, checkMode);
|
|
case 281 /* JsxElement */:
|
|
return checkJsxElement(node, checkMode);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return checkJsxSelfClosingElement(node, checkMode);
|
|
case 285 /* JsxFragment */:
|
|
return checkJsxFragment(node);
|
|
case 289 /* JsxAttributes */:
|
|
return checkJsxAttributes(node, checkMode);
|
|
case 283 /* JsxOpeningElement */:
|
|
Debug.fail("Shouldn't ever directly check a JsxOpeningElement");
|
|
}
|
|
return errorType;
|
|
}
|
|
function checkTypeParameter(node) {
|
|
checkGrammarModifiers(node);
|
|
if (node.expression) {
|
|
grammarErrorOnFirstToken(node.expression, Diagnostics.Type_expected);
|
|
}
|
|
checkSourceElement(node.constraint);
|
|
checkSourceElement(node.default);
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
|
|
getBaseConstraintOfType(typeParameter);
|
|
if (!hasNonCircularTypeParameterDefault(typeParameter)) {
|
|
error(node.default, Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter));
|
|
}
|
|
const constraintType = getConstraintOfTypeParameter(typeParameter);
|
|
const defaultType = getDefaultFromTypeParameter(typeParameter);
|
|
if (constraintType && defaultType) {
|
|
checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
|
|
}
|
|
checkNodeDeferred(node);
|
|
addLazyDiagnostic(() => checkTypeNameIsReserved(node.name, Diagnostics.Type_parameter_name_cannot_be_0));
|
|
}
|
|
function checkTypeParameterDeferred(node) {
|
|
var _a2, _b;
|
|
if (isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent)) {
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
|
|
const modifiers = getVarianceModifiers(typeParameter);
|
|
if (modifiers) {
|
|
const symbol = getSymbolOfNode(node.parent);
|
|
if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
|
|
error(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
|
|
} else if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) });
|
|
const source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubTypeForCheck : markerSuperTypeForCheck);
|
|
const target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperTypeForCheck : markerSubTypeForCheck);
|
|
const saveVarianceTypeParameter = typeParameter;
|
|
varianceTypeParameter = typeParameter;
|
|
checkTypeAssignableTo(source, target, node, Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
|
|
varianceTypeParameter = saveVarianceTypeParameter;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkParameter(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkVariableLikeDeclaration(node);
|
|
const func = getContainingFunction(node);
|
|
if (hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
|
|
if (!(func.kind === 173 /* Constructor */ && nodeIsPresent(func.body))) {
|
|
error(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
|
|
}
|
|
if (func.kind === 173 /* Constructor */ && isIdentifier(node.name) && node.name.escapedText === "constructor") {
|
|
error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
|
|
}
|
|
}
|
|
if ((node.questionToken || isJSDocOptionalParameter(node)) && isBindingPattern(node.name) && func.body) {
|
|
error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
|
|
}
|
|
if (node.name && isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
|
|
if (func.parameters.indexOf(node) !== 0) {
|
|
error(node, Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText);
|
|
}
|
|
if (func.kind === 173 /* Constructor */ || func.kind === 177 /* ConstructSignature */ || func.kind === 182 /* ConstructorType */) {
|
|
error(node, Diagnostics.A_constructor_cannot_have_a_this_parameter);
|
|
}
|
|
if (func.kind === 216 /* ArrowFunction */) {
|
|
error(node, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
|
|
}
|
|
if (func.kind === 174 /* GetAccessor */ || func.kind === 175 /* SetAccessor */) {
|
|
error(node, Diagnostics.get_and_set_accessors_cannot_declare_this_parameters);
|
|
}
|
|
}
|
|
if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type);
|
|
}
|
|
}
|
|
function checkTypePredicate(node) {
|
|
const parent = getTypePredicateParent(node);
|
|
if (!parent) {
|
|
error(node, Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
|
|
return;
|
|
}
|
|
const signature = getSignatureFromDeclaration(parent);
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (!typePredicate) {
|
|
return;
|
|
}
|
|
checkSourceElement(node.type);
|
|
const { parameterName } = node;
|
|
if (typePredicate.kind === 0 /* This */ || typePredicate.kind === 2 /* AssertsThis */) {
|
|
getTypeFromThisTypeNode(parameterName);
|
|
} else {
|
|
if (typePredicate.parameterIndex >= 0) {
|
|
if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) {
|
|
error(parameterName, Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
|
|
} else {
|
|
if (typePredicate.type) {
|
|
const leadingError = () => chainDiagnosticMessages(void 0, Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type);
|
|
checkTypeAssignableTo(
|
|
typePredicate.type,
|
|
getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]),
|
|
node.type,
|
|
void 0,
|
|
leadingError
|
|
);
|
|
}
|
|
}
|
|
} else if (parameterName) {
|
|
let hasReportedError = false;
|
|
for (const { name } of parent.parameters) {
|
|
if (isBindingPattern(name) && checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) {
|
|
hasReportedError = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasReportedError) {
|
|
error(node.parameterName, Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypePredicateParent(node) {
|
|
switch (node.parent.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 176 /* CallSignature */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 181 /* FunctionType */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
const parent = node.parent;
|
|
if (node === parent.type) {
|
|
return parent;
|
|
}
|
|
}
|
|
}
|
|
function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) {
|
|
for (const element of pattern.elements) {
|
|
if (isOmittedExpression(element)) {
|
|
continue;
|
|
}
|
|
const name = element.name;
|
|
if (name.kind === 79 /* Identifier */ && name.escapedText === predicateVariableName) {
|
|
error(
|
|
predicateVariableNode,
|
|
Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern,
|
|
predicateVariableName
|
|
);
|
|
return true;
|
|
} else if (name.kind === 204 /* ArrayBindingPattern */ || name.kind === 203 /* ObjectBindingPattern */) {
|
|
if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(
|
|
name,
|
|
predicateVariableNode,
|
|
predicateVariableName
|
|
)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkSignatureDeclaration(node) {
|
|
if (node.kind === 178 /* IndexSignature */) {
|
|
checkGrammarIndexSignature(node);
|
|
} else if (node.kind === 181 /* FunctionType */ || node.kind === 259 /* FunctionDeclaration */ || node.kind === 182 /* ConstructorType */ || node.kind === 176 /* CallSignature */ || node.kind === 173 /* Constructor */ || node.kind === 177 /* ConstructSignature */) {
|
|
checkGrammarFunctionLikeDeclaration(node);
|
|
}
|
|
const functionFlags = getFunctionFlags(node);
|
|
if (!(functionFlags & 4 /* Invalid */)) {
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */);
|
|
}
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* ES2017 */) {
|
|
checkExternalEmitHelpers(node, 64 /* Awaiter */);
|
|
}
|
|
if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 128 /* Generator */);
|
|
}
|
|
}
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
checkUnmatchedJSDocParameters(node);
|
|
forEach(node.parameters, checkParameter);
|
|
if (node.type) {
|
|
checkSourceElement(node.type);
|
|
}
|
|
addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
|
|
function checkSignatureDeclarationDiagnostics() {
|
|
checkCollisionWithArgumentsInGeneratedCode(node);
|
|
const returnTypeNode = getEffectiveReturnTypeNode(node);
|
|
if (noImplicitAny && !returnTypeNode) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
error(node, Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
error(node, Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
|
|
break;
|
|
}
|
|
}
|
|
if (returnTypeNode) {
|
|
const functionFlags2 = getFunctionFlags(node);
|
|
if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
|
|
const returnType = getTypeFromTypeNode(returnTypeNode);
|
|
if (returnType === voidType) {
|
|
error(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
|
|
} else {
|
|
const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
|
|
const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
|
|
const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
|
|
const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
|
|
checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
|
|
}
|
|
} else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
|
|
checkAsyncFunctionReturnType(node, returnTypeNode);
|
|
}
|
|
}
|
|
if (node.kind !== 178 /* IndexSignature */ && node.kind !== 320 /* JSDocFunctionType */) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
}
|
|
function checkClassForDuplicateDeclarations(node) {
|
|
const instanceNames = /* @__PURE__ */ new Map();
|
|
const staticNames = /* @__PURE__ */ new Map();
|
|
const privateIdentifiers = /* @__PURE__ */ new Map();
|
|
for (const member of node.members) {
|
|
if (member.kind === 173 /* Constructor */) {
|
|
for (const param of member.parameters) {
|
|
if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(param.name)) {
|
|
addName(instanceNames, param.name, param.name.escapedText, 3 /* GetOrSetAccessor */);
|
|
}
|
|
}
|
|
} else {
|
|
const isStaticMember = isStatic(member);
|
|
const name = member.name;
|
|
if (!name) {
|
|
continue;
|
|
}
|
|
const isPrivate = isPrivateIdentifier(name);
|
|
const privateStaticFlags = isPrivate && isStaticMember ? 16 /* PrivateStatic */ : 0;
|
|
const names = isPrivate ? privateIdentifiers : isStaticMember ? staticNames : instanceNames;
|
|
const memberName = name && getPropertyNameForPropertyNameNode(name);
|
|
if (memberName) {
|
|
switch (member.kind) {
|
|
case 174 /* GetAccessor */:
|
|
addName(names, name, memberName, 1 /* GetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 175 /* SetAccessor */:
|
|
addName(names, name, memberName, 2 /* SetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
addName(names, name, memberName, 3 /* GetOrSetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
addName(names, name, memberName, 8 /* Method */ | privateStaticFlags);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addName(names, location, name, meaning) {
|
|
const prev = names.get(name);
|
|
if (prev) {
|
|
if ((prev & 16 /* PrivateStatic */) !== (meaning & 16 /* PrivateStatic */)) {
|
|
error(location, Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name, getTextOfNode(location));
|
|
} else {
|
|
const prevIsMethod = !!(prev & 8 /* Method */);
|
|
const isMethod = !!(meaning & 8 /* Method */);
|
|
if (prevIsMethod || isMethod) {
|
|
if (prevIsMethod !== isMethod) {
|
|
error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
|
|
}
|
|
} else if (prev & meaning & ~16 /* PrivateStatic */) {
|
|
error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
|
|
} else {
|
|
names.set(name, prev | meaning);
|
|
}
|
|
}
|
|
} else {
|
|
names.set(name, meaning);
|
|
}
|
|
}
|
|
}
|
|
function checkClassForStaticPropertyNameConflicts(node) {
|
|
for (const member of node.members) {
|
|
const memberNameNode = member.name;
|
|
const isStaticMember = isStatic(member);
|
|
if (isStaticMember && memberNameNode) {
|
|
const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
|
|
switch (memberName) {
|
|
case "name":
|
|
case "length":
|
|
case "caller":
|
|
case "arguments":
|
|
case "prototype":
|
|
const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
|
|
const className = getNameOfSymbolAsWritten(getSymbolOfNode(node));
|
|
error(memberNameNode, message, memberName, className);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkObjectTypeForDuplicateDeclarations(node) {
|
|
const names = /* @__PURE__ */ new Map();
|
|
for (const member of node.members) {
|
|
if (member.kind === 168 /* PropertySignature */) {
|
|
let memberName;
|
|
const name = member.name;
|
|
switch (name.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
memberName = name.text;
|
|
break;
|
|
case 79 /* Identifier */:
|
|
memberName = idText(name);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
if (names.get(memberName)) {
|
|
error(getNameOfDeclaration(member.symbol.valueDeclaration), Diagnostics.Duplicate_identifier_0, memberName);
|
|
error(member.name, Diagnostics.Duplicate_identifier_0, memberName);
|
|
} else {
|
|
names.set(memberName, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkTypeForDuplicateIndexSignatures(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */) {
|
|
const nodeSymbol = getSymbolOfNode(node);
|
|
if (nodeSymbol.declarations && nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
|
|
return;
|
|
}
|
|
}
|
|
const indexSymbol = getIndexSymbol(getSymbolOfNode(node));
|
|
if (indexSymbol == null ? void 0 : indexSymbol.declarations) {
|
|
const indexSignatureMap = /* @__PURE__ */ new Map();
|
|
for (const declaration of indexSymbol.declarations) {
|
|
if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
|
|
forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
|
|
const entry = indexSignatureMap.get(getTypeId(type));
|
|
if (entry) {
|
|
entry.declarations.push(declaration);
|
|
} else {
|
|
indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
|
|
}
|
|
});
|
|
}
|
|
}
|
|
indexSignatureMap.forEach((entry) => {
|
|
if (entry.declarations.length > 1) {
|
|
for (const declaration of entry.declarations) {
|
|
error(declaration, Diagnostics.Duplicate_index_signature_for_type_0, typeToString(entry.type));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkPropertyDeclaration(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
checkVariableLikeDeclaration(node);
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 169 /* PropertyDeclaration */ && node.initializer) {
|
|
error(node, Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
function checkPropertySignature(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
error(node, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
return checkPropertyDeclaration(node);
|
|
}
|
|
function checkMethodDeclaration(node) {
|
|
if (!checkGrammarMethod(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
if (isMethodDeclaration(node) && node.asteriskToken && isIdentifier(node.name) && idText(node.name) === "constructor") {
|
|
error(node.name, Diagnostics.Class_constructor_may_not_be_a_generator);
|
|
}
|
|
checkFunctionOrMethodDeclaration(node);
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 171 /* MethodDeclaration */ && node.body) {
|
|
error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name));
|
|
}
|
|
if (isPrivateIdentifier(node.name) && !getContainingClass(node)) {
|
|
error(node, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
}
|
|
function setNodeLinksForPrivateIdentifierScope(node) {
|
|
if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
|
|
for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
|
|
getNodeLinks(lexicalScope).flags |= 4194304 /* ContainsClassWithPrivateIdentifiers */;
|
|
}
|
|
if (isClassExpression(node.parent)) {
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
|
|
if (enclosingIterationStatement) {
|
|
getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkClassStaticBlockDeclaration(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
forEachChild(node, checkSourceElement);
|
|
}
|
|
function checkConstructorDeclaration(node) {
|
|
checkSignatureDeclaration(node);
|
|
if (!checkGrammarConstructorTypeParameters(node))
|
|
checkGrammarConstructorTypeAnnotation(node);
|
|
checkSourceElement(node.body);
|
|
const symbol = getSymbolOfNode(node);
|
|
const firstDeclaration = getDeclarationOfKind(symbol, node.kind);
|
|
if (node === firstDeclaration) {
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
}
|
|
if (nodeIsMissing(node.body)) {
|
|
return;
|
|
}
|
|
addLazyDiagnostic(checkConstructorDeclarationDiagnostics);
|
|
return;
|
|
function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
|
|
if (isPrivateIdentifierClassElementDeclaration(n)) {
|
|
return true;
|
|
}
|
|
return n.kind === 169 /* PropertyDeclaration */ && !isStatic(n) && !!n.initializer;
|
|
}
|
|
function checkConstructorDeclarationDiagnostics() {
|
|
const containingClassDecl = node.parent;
|
|
if (getClassExtendsHeritageElement(containingClassDecl)) {
|
|
captureLexicalThis(node.parent, containingClassDecl);
|
|
const classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
|
|
const superCall = findFirstSuperCall(node.body);
|
|
if (superCall) {
|
|
if (classExtendsNull) {
|
|
error(superCall, Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
|
|
}
|
|
const superCallShouldBeRootLevel = (getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) && (some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || some(node.parameters, (p) => hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */)));
|
|
if (superCallShouldBeRootLevel) {
|
|
if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
|
|
error(superCall, 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);
|
|
} else {
|
|
let superCallStatement;
|
|
for (const statement of node.body.statements) {
|
|
if (isExpressionStatement(statement) && isSuperCall(skipOuterExpressions(statement.expression))) {
|
|
superCallStatement = statement;
|
|
break;
|
|
}
|
|
if (nodeImmediatelyReferencesSuperOrThis(statement)) {
|
|
break;
|
|
}
|
|
}
|
|
if (superCallStatement === void 0) {
|
|
error(node, 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, Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function superCallIsRootLevelInConstructor(superCall, body) {
|
|
const superCallParent = walkUpParenthesizedExpressions(superCall.parent);
|
|
return isExpressionStatement(superCallParent) && superCallParent.parent === body;
|
|
}
|
|
function nodeImmediatelyReferencesSuperOrThis(node) {
|
|
if (node.kind === 106 /* SuperKeyword */ || node.kind === 108 /* ThisKeyword */) {
|
|
return true;
|
|
}
|
|
if (isThisContainerOrFunctionBlock(node)) {
|
|
return false;
|
|
}
|
|
return !!forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
|
|
}
|
|
function checkAccessorDeclaration(node) {
|
|
if (isIdentifier(node.name) && idText(node.name) === "constructor") {
|
|
error(node.name, Diagnostics.Class_constructor_may_not_be_an_accessor);
|
|
}
|
|
addLazyDiagnostic(checkAccessorDeclarationDiagnostics);
|
|
checkSourceElement(node.body);
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
function checkAccessorDeclarationDiagnostics() {
|
|
if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
checkDecorators(node);
|
|
checkSignatureDeclaration(node);
|
|
if (node.kind === 174 /* GetAccessor */) {
|
|
if (!(node.flags & 16777216 /* Ambient */) && nodeIsPresent(node.body) && node.flags & 256 /* HasImplicitReturn */) {
|
|
if (!(node.flags & 512 /* HasExplicitReturn */)) {
|
|
error(node.name, Diagnostics.A_get_accessor_must_return_a_value);
|
|
}
|
|
}
|
|
}
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
if (hasBindableName(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const getter = getDeclarationOfKind(symbol, 174 /* GetAccessor */);
|
|
const setter = getDeclarationOfKind(symbol, 175 /* SetAccessor */);
|
|
if (getter && setter && !(getNodeCheckFlags(getter) & 1 /* TypeChecked */)) {
|
|
getNodeLinks(getter).flags |= 1 /* TypeChecked */;
|
|
const getterFlags = getEffectiveModifierFlags(getter);
|
|
const setterFlags = getEffectiveModifierFlags(setter);
|
|
if ((getterFlags & 256 /* Abstract */) !== (setterFlags & 256 /* Abstract */)) {
|
|
error(getter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
|
|
error(setter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
|
|
}
|
|
if (getterFlags & 16 /* Protected */ && !(setterFlags & (16 /* Protected */ | 8 /* Private */)) || getterFlags & 8 /* Private */ && !(setterFlags & 8 /* Private */)) {
|
|
error(getter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
|
|
error(setter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
|
|
}
|
|
const getterType = getAnnotatedAccessorType(getter);
|
|
const setterType = getAnnotatedAccessorType(setter);
|
|
if (getterType && setterType) {
|
|
checkTypeAssignableTo(getterType, setterType, getter, Diagnostics.The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type);
|
|
}
|
|
}
|
|
}
|
|
const returnType = getTypeOfAccessors(getSymbolOfNode(node));
|
|
if (node.kind === 174 /* 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(
|
|
map(node.typeArguments, getTypeFromTypeNode),
|
|
typeParameters,
|
|
getMinTypeArgumentCount(typeParameters),
|
|
isInJSFile(node)
|
|
);
|
|
}
|
|
function checkTypeArgumentConstraints(node, typeParameters) {
|
|
let typeArguments;
|
|
let mapper;
|
|
let result = true;
|
|
for (let i = 0; i < typeParameters.length; i++) {
|
|
const 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],
|
|
Diagnostics.Type_0_does_not_satisfy_the_constraint_1
|
|
);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeParametersForTypeReference(node) {
|
|
const type = getTypeFromTypeReference(node);
|
|
if (!isErrorType(type)) {
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol) {
|
|
return symbol.flags & 524288 /* TypeAlias */ && getSymbolLinks(symbol).typeParameters || (getObjectFlags(type) & 4 /* Reference */ ? type.target.localTypeParameters : void 0);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkTypeReferenceNode(node) {
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
if (node.kind === 180 /* TypeReference */ && node.typeName.jsdocDotPos !== void 0 && !isInJSFile(node) && !isInJSDoc(node)) {
|
|
grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
|
|
}
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
const type = getTypeFromTypeReference(node);
|
|
if (!isErrorType(type)) {
|
|
if (node.typeArguments) {
|
|
addLazyDiagnostic(() => {
|
|
const typeParameters = getTypeParametersForTypeReference(node);
|
|
if (typeParameters) {
|
|
checkTypeArgumentConstraints(node, typeParameters);
|
|
}
|
|
});
|
|
}
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol) {
|
|
if (some(symbol.declarations, (d) => isTypeDeclaration(d) && !!(d.flags & 268435456 /* Deprecated */))) {
|
|
addDeprecatedSuggestion(
|
|
getDeprecatedSuggestionNode(node),
|
|
symbol.declarations,
|
|
symbol.escapedName
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypeArgumentConstraint(node) {
|
|
const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
|
|
if (!typeReferenceNode)
|
|
return void 0;
|
|
const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
|
|
if (!typeParameters)
|
|
return void 0;
|
|
const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
|
|
return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters)));
|
|
}
|
|
function checkTypeQuery(node) {
|
|
getTypeFromTypeQueryNode(node);
|
|
}
|
|
function checkTypeLiteral(node) {
|
|
forEach(node.members, checkSourceElement);
|
|
addLazyDiagnostic(checkTypeLiteralDiagnostics);
|
|
function checkTypeLiteralDiagnostics() {
|
|
const type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
|
|
checkIndexConstraints(type, type.symbol);
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
checkObjectTypeForDuplicateDeclarations(node);
|
|
}
|
|
}
|
|
function checkArrayType(node) {
|
|
checkSourceElement(node.elementType);
|
|
}
|
|
function checkTupleType(node) {
|
|
const elementTypes = node.elements;
|
|
let seenOptionalElement = false;
|
|
let seenRestElement = false;
|
|
const hasNamedElement = some(elementTypes, isNamedTupleMember);
|
|
for (const e of elementTypes) {
|
|
if (e.kind !== 199 /* NamedTupleMember */ && hasNamedElement) {
|
|
grammarErrorOnNode(e, Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names);
|
|
break;
|
|
}
|
|
const flags = getTupleElementFlags(e);
|
|
if (flags & 8 /* Variadic */) {
|
|
const type = getTypeFromTypeNode(e.type);
|
|
if (!isArrayLikeType(type)) {
|
|
error(e, Diagnostics.A_rest_element_type_must_be_an_array_type);
|
|
break;
|
|
}
|
|
if (isArrayType(type) || isTupleType(type) && type.target.combinedFlags & 4 /* Rest */) {
|
|
seenRestElement = true;
|
|
}
|
|
} else if (flags & 4 /* Rest */) {
|
|
if (seenRestElement) {
|
|
grammarErrorOnNode(e, Diagnostics.A_rest_element_cannot_follow_another_rest_element);
|
|
break;
|
|
}
|
|
seenRestElement = true;
|
|
} else if (flags & 2 /* Optional */) {
|
|
if (seenRestElement) {
|
|
grammarErrorOnNode(e, Diagnostics.An_optional_element_cannot_follow_a_rest_element);
|
|
break;
|
|
}
|
|
seenOptionalElement = true;
|
|
} else if (seenOptionalElement) {
|
|
grammarErrorOnNode(e, Diagnostics.A_required_element_cannot_follow_an_optional_element);
|
|
break;
|
|
}
|
|
}
|
|
forEach(node.elements, checkSourceElement);
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkUnionOrIntersectionType(node) {
|
|
forEach(node.types, checkSourceElement);
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkIndexedAccessIndexType(type, accessNode) {
|
|
if (!(type.flags & 8388608 /* IndexedAccess */)) {
|
|
return type;
|
|
}
|
|
const objectType = type.objectType;
|
|
const indexType = type.indexType;
|
|
if (isTypeAssignableTo(indexType, getIndexType(objectType, false))) {
|
|
if (accessNode.kind === 209 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
|
|
error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
|
|
}
|
|
return type;
|
|
}
|
|
const apparentObjectType = getApparentType(objectType);
|
|
if (getIndexInfoOfType(apparentObjectType, numberType) && isTypeAssignableToKind(indexType, 296 /* NumberLike */)) {
|
|
return type;
|
|
}
|
|
if (isGenericObjectType(objectType)) {
|
|
const propertyName = getPropertyNameFromIndex(indexType, accessNode);
|
|
if (propertyName) {
|
|
const propertySymbol = forEachType(apparentObjectType, (t) => getPropertyOfType(t, propertyName));
|
|
if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24 /* NonPublicAccessibilityModifier */) {
|
|
error(accessNode, Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, unescapeLeadingUnderscores(propertyName));
|
|
return errorType;
|
|
}
|
|
}
|
|
}
|
|
error(accessNode, 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);
|
|
}
|
|
const type = getTypeFromMappedTypeNode(node);
|
|
const nameType = getNameTypeFromMappedType(type);
|
|
if (nameType) {
|
|
checkTypeAssignableTo(nameType, keyofConstraintType, node.nameType);
|
|
} else {
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
checkTypeAssignableTo(constraintType, keyofConstraintType, getEffectiveConstraintOfTypeParameter(node.typeParameter));
|
|
}
|
|
}
|
|
function checkGrammarMappedType(node) {
|
|
var _a2;
|
|
if ((_a2 = node.members) == null ? void 0 : _a2.length) {
|
|
return grammarErrorOnNode(node.members[0], 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) {
|
|
forEachChild(node, checkSourceElement);
|
|
}
|
|
function checkInferType(node) {
|
|
if (!findAncestor(node, (n) => n.parent && n.parent.kind === 191 /* ConditionalType */ && n.parent.extendsType === n)) {
|
|
grammarErrorOnNode(node, Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type);
|
|
}
|
|
checkSourceElement(node.typeParameter);
|
|
const symbol = getSymbolOfNode(node.typeParameter);
|
|
if (symbol.declarations && symbol.declarations.length > 1) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.typeParametersChecked) {
|
|
links.typeParametersChecked = true;
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(symbol);
|
|
const declarations = getDeclarationsOfKind(symbol, 165 /* TypeParameter */);
|
|
if (!areTypeParametersIdentical(declarations, [typeParameter], (decl) => [decl])) {
|
|
const name = symbolToString(symbol);
|
|
for (const declaration of declarations) {
|
|
error(declaration.name, Diagnostics.All_declarations_of_0_must_have_identical_constraints, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkTemplateLiteralType(node) {
|
|
for (const span of node.templateSpans) {
|
|
checkSourceElement(span.type);
|
|
const type = getTypeFromTypeNode(span.type);
|
|
checkTypeAssignableTo(type, templateConstraintType, span.type);
|
|
}
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkImportType(node) {
|
|
checkSourceElement(node.argument);
|
|
if (node.assertions) {
|
|
const override = getResolutionModeOverrideForClause(node.assertions.assertClause, grammarErrorOnNode);
|
|
if (override) {
|
|
if (!isNightly()) {
|
|
grammarErrorOnNode(node.assertions.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
grammarErrorOnNode(node.assertions.assertClause, 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, Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest);
|
|
}
|
|
if (node.type.kind === 187 /* OptionalType */) {
|
|
grammarErrorOnNode(node.type, 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 /* RestType */) {
|
|
grammarErrorOnNode(node.type, 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 (hasEffectiveModifier(node, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 16777216 /* Ambient */);
|
|
}
|
|
function getEffectiveDeclarationFlags(n, flagsToCheck) {
|
|
let flags = getCombinedModifierFlags(n);
|
|
if (n.parent.kind !== 261 /* InterfaceDeclaration */ && n.parent.kind !== 260 /* ClassDeclaration */ && n.parent.kind !== 228 /* ClassExpression */ && n.flags & 16777216 /* Ambient */) {
|
|
if (!(flags & 2 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
|
|
flags |= 1 /* Export */;
|
|
}
|
|
flags |= 2 /* Ambient */;
|
|
}
|
|
return flags & flagsToCheck;
|
|
}
|
|
function checkFunctionOrConstructorSymbol(symbol) {
|
|
addLazyDiagnostic(() => checkFunctionOrConstructorSymbolWorker(symbol));
|
|
}
|
|
function checkFunctionOrConstructorSymbolWorker(symbol) {
|
|
function getCanonicalOverload(overloads, implementation) {
|
|
const implementationSharesContainerWithFirstOverload = implementation !== void 0 && implementation.parent === overloads[0].parent;
|
|
return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
|
|
}
|
|
function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck2, someOverloadFlags, allOverloadFlags) {
|
|
const someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
|
|
if (someButNotAllOverloadFlags !== 0) {
|
|
const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
|
|
forEach(overloads, (o) => {
|
|
const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
|
|
if (deviation & 1 /* Export */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
|
|
} else if (deviation & 2 /* Ambient */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
|
|
} else if (deviation & (8 /* Private */ | 16 /* Protected */)) {
|
|
error(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
|
|
} else if (deviation & 256 /* Abstract */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken2, allHaveQuestionToken2) {
|
|
if (someHaveQuestionToken2 !== allHaveQuestionToken2) {
|
|
const canonicalHasQuestionToken = hasQuestionToken(getCanonicalOverload(overloads, implementation));
|
|
forEach(overloads, (o) => {
|
|
const deviation = hasQuestionToken(o) !== canonicalHasQuestionToken;
|
|
if (deviation) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_optional_or_required);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
const flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 8 /* Private */ | 16 /* Protected */ | 256 /* Abstract */;
|
|
let someNodeFlags = 0 /* None */;
|
|
let allNodeFlags = flagsToCheck;
|
|
let someHaveQuestionToken = false;
|
|
let allHaveQuestionToken = true;
|
|
let hasOverloads = false;
|
|
let bodyDeclaration;
|
|
let lastSeenNonAmbientDeclaration;
|
|
let previousDeclaration;
|
|
const declarations = symbol.declarations;
|
|
const isConstructor = (symbol.flags & 16384 /* Constructor */) !== 0;
|
|
function reportImplementationExpectedError(node) {
|
|
if (node.name && nodeIsMissing(node.name)) {
|
|
return;
|
|
}
|
|
let seen = false;
|
|
const subsequentNode = forEachChild(node.parent, (c) => {
|
|
if (seen) {
|
|
return c;
|
|
} else {
|
|
seen = c === node;
|
|
}
|
|
});
|
|
if (subsequentNode && subsequentNode.pos === node.end) {
|
|
if (subsequentNode.kind === node.kind) {
|
|
const errorNode2 = subsequentNode.name || subsequentNode;
|
|
const subsequentName = subsequentNode.name;
|
|
if (node.name && subsequentName && (isPrivateIdentifier(node.name) && isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText || isComputedPropertyName(node.name) && isComputedPropertyName(subsequentName) || isPropertyNameLiteral(node.name) && isPropertyNameLiteral(subsequentName) && getEscapedTextOfIdentifierOrLiteral(node.name) === getEscapedTextOfIdentifierOrLiteral(subsequentName))) {
|
|
const reportError = (node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */) && isStatic(node) !== isStatic(subsequentNode);
|
|
if (reportError) {
|
|
const diagnostic = isStatic(node) ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
|
|
error(errorNode2, diagnostic);
|
|
}
|
|
return;
|
|
}
|
|
if (nodeIsPresent(subsequentNode.body)) {
|
|
error(errorNode2, Diagnostics.Function_implementation_name_must_be_0, declarationNameToString(node.name));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
const errorNode = node.name || node;
|
|
if (isConstructor) {
|
|
error(errorNode, Diagnostics.Constructor_implementation_is_missing);
|
|
} else {
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */)) {
|
|
error(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
|
|
} else {
|
|
error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
|
|
}
|
|
}
|
|
}
|
|
let duplicateFunctionDeclaration = false;
|
|
let multipleConstructorImplementation = false;
|
|
let hasNonAmbientClass = false;
|
|
const functionDeclarations = [];
|
|
if (declarations) {
|
|
for (const current of declarations) {
|
|
const node = current;
|
|
const inAmbientContext = node.flags & 16777216 /* Ambient */;
|
|
const inAmbientContextOrInterface = node.parent && (node.parent.kind === 261 /* InterfaceDeclaration */ || node.parent.kind === 184 /* TypeLiteral */) || inAmbientContext;
|
|
if (inAmbientContextOrInterface) {
|
|
previousDeclaration = void 0;
|
|
}
|
|
if ((node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */) && !inAmbientContext) {
|
|
hasNonAmbientClass = true;
|
|
}
|
|
if (node.kind === 259 /* FunctionDeclaration */ || node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */ || node.kind === 173 /* Constructor */) {
|
|
functionDeclarations.push(node);
|
|
const currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
|
|
someNodeFlags |= currentNodeFlags;
|
|
allNodeFlags &= currentNodeFlags;
|
|
someHaveQuestionToken = someHaveQuestionToken || hasQuestionToken(node);
|
|
allHaveQuestionToken = allHaveQuestionToken && hasQuestionToken(node);
|
|
const bodyIsPresent = nodeIsPresent(node.body);
|
|
if (bodyIsPresent && bodyDeclaration) {
|
|
if (isConstructor) {
|
|
multipleConstructorImplementation = true;
|
|
} else {
|
|
duplicateFunctionDeclaration = true;
|
|
}
|
|
} else if ((previousDeclaration == null ? 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) {
|
|
forEach(functionDeclarations, (declaration) => {
|
|
error(declaration, Diagnostics.Multiple_constructor_implementations_are_not_allowed);
|
|
});
|
|
}
|
|
if (duplicateFunctionDeclaration) {
|
|
forEach(functionDeclarations, (declaration) => {
|
|
error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Duplicate_function_implementation);
|
|
});
|
|
}
|
|
if (hasNonAmbientClass && !isConstructor && symbol.flags & 16 /* Function */ && declarations) {
|
|
const relatedDiagnostics = filter(declarations, (d) => d.kind === 260 /* ClassDeclaration */).map((d) => createDiagnosticForNode(d, Diagnostics.Consider_adding_a_declare_modifier_to_this_class));
|
|
forEach(declarations, (declaration) => {
|
|
const diagnostic = declaration.kind === 260 /* ClassDeclaration */ ? Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 : declaration.kind === 259 /* FunctionDeclaration */ ? Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient : void 0;
|
|
if (diagnostic) {
|
|
addRelatedInfo(
|
|
error(getNameOfDeclaration(declaration) || declaration, diagnostic, symbolName(symbol)),
|
|
...relatedDiagnostics
|
|
);
|
|
}
|
|
});
|
|
}
|
|
if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
|
|
reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
|
|
}
|
|
if (hasOverloads) {
|
|
if (declarations) {
|
|
checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags);
|
|
checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
|
|
}
|
|
if (bodyDeclaration) {
|
|
const signatures = getSignaturesOfSymbol(symbol);
|
|
const bodySignature = getSignatureFromDeclaration(bodyDeclaration);
|
|
for (const signature of signatures) {
|
|
if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
|
|
addRelatedInfo(
|
|
error(signature.declaration, Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature),
|
|
createDiagnosticForNode(bodyDeclaration, Diagnostics.The_implementation_signature_is_declared_here)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkExportsOnMergedDeclarations(node) {
|
|
addLazyDiagnostic(() => checkExportsOnMergedDeclarationsWorker(node));
|
|
}
|
|
function checkExportsOnMergedDeclarationsWorker(node) {
|
|
let symbol = node.localSymbol;
|
|
if (!symbol) {
|
|
symbol = getSymbolOfNode(node);
|
|
if (!symbol.exportSymbol) {
|
|
return;
|
|
}
|
|
}
|
|
if (getDeclarationOfKind(symbol, node.kind) !== node) {
|
|
return;
|
|
}
|
|
let exportedDeclarationSpaces = 0 /* None */;
|
|
let nonExportedDeclarationSpaces = 0 /* None */;
|
|
let defaultExportedDeclarationSpaces = 0 /* None */;
|
|
for (const d of symbol.declarations) {
|
|
const declarationSpaces = getDeclarationSpaces(d);
|
|
const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
|
|
if (effectiveDeclarationFlags & 1 /* Export */) {
|
|
if (effectiveDeclarationFlags & 1024 /* Default */) {
|
|
defaultExportedDeclarationSpaces |= declarationSpaces;
|
|
} else {
|
|
exportedDeclarationSpaces |= declarationSpaces;
|
|
}
|
|
} else {
|
|
nonExportedDeclarationSpaces |= declarationSpaces;
|
|
}
|
|
}
|
|
const nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
|
|
const commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
|
|
const commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
|
|
if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
|
|
for (const d of symbol.declarations) {
|
|
const declarationSpaces = getDeclarationSpaces(d);
|
|
const name = getNameOfDeclaration(d);
|
|
if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
|
|
error(name, Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, declarationNameToString(name));
|
|
} else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) {
|
|
error(name, Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, declarationNameToString(name));
|
|
}
|
|
}
|
|
}
|
|
function getDeclarationSpaces(decl) {
|
|
let d = decl;
|
|
switch (d.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return 2 /* ExportType */;
|
|
case 264 /* ModuleDeclaration */:
|
|
return isAmbientModule(d) || getModuleInstanceState(d) !== 0 /* NonInstantiated */ ? 4 /* ExportNamespace */ | 1 /* ExportValue */ : 4 /* ExportNamespace */;
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
return 2 /* ExportType */ | 1 /* ExportValue */;
|
|
case 308 /* SourceFile */:
|
|
return 2 /* ExportType */ | 1 /* ExportValue */ | 4 /* ExportNamespace */;
|
|
case 274 /* ExportAssignment */:
|
|
case 223 /* BinaryExpression */:
|
|
const node2 = d;
|
|
const expression = isExportAssignment(node2) ? node2.expression : node2.right;
|
|
if (!isEntityNameExpression(expression)) {
|
|
return 1 /* ExportValue */;
|
|
}
|
|
d = expression;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 271 /* NamespaceImport */:
|
|
case 270 /* ImportClause */:
|
|
let result = 0 /* None */;
|
|
const target = resolveAlias(getSymbolOfNode(d));
|
|
forEach(target.declarations, (d2) => {
|
|
result |= getDeclarationSpaces(d2);
|
|
});
|
|
return result;
|
|
case 257 /* VariableDeclaration */:
|
|
case 205 /* BindingElement */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 79 /* Identifier */:
|
|
return 1 /* ExportValue */;
|
|
default:
|
|
return Debug.failBadSyntaxKind(d);
|
|
}
|
|
}
|
|
}
|
|
function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
|
|
const promisedType = getPromisedTypeOfPromise(type, errorNode);
|
|
return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
|
|
}
|
|
function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) {
|
|
if (isTypeAny(type)) {
|
|
return void 0;
|
|
}
|
|
const typeAsPromise = type;
|
|
if (typeAsPromise.promisedTypeOfPromise) {
|
|
return typeAsPromise.promisedTypeOfPromise;
|
|
}
|
|
if (isReferenceToType(type, getGlobalPromiseType(false))) {
|
|
return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
|
|
}
|
|
if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
|
|
return void 0;
|
|
}
|
|
const thenFunction = getTypeOfPropertyOfType(type, "then");
|
|
if (isTypeAny(thenFunction)) {
|
|
return void 0;
|
|
}
|
|
const thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0 /* Call */) : emptyArray;
|
|
if (thenSignatures.length === 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.A_promise_must_have_a_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
let thisTypeForError;
|
|
let candidates;
|
|
for (const thenSignature of thenSignatures) {
|
|
const thisType = getThisTypeOfSignature(thenSignature);
|
|
if (thisType && thisType !== voidType && !isTypeRelatedTo(type, thisType, subtypeRelation)) {
|
|
thisTypeForError = thisType;
|
|
} else {
|
|
candidates = append(candidates, thenSignature);
|
|
}
|
|
}
|
|
if (!candidates) {
|
|
Debug.assertIsDefined(thisTypeForError);
|
|
if (thisTypeForErrorOut) {
|
|
thisTypeForErrorOut.value = thisTypeForError;
|
|
}
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForError));
|
|
}
|
|
return void 0;
|
|
}
|
|
const onfulfilledParameterType = getTypeWithFacts(getUnionType(map(candidates, getTypeOfFirstParameterOfSignature)), 2097152 /* NEUndefinedOrNull */);
|
|
if (isTypeAny(onfulfilledParameterType)) {
|
|
return void 0;
|
|
}
|
|
const onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0 /* Call */);
|
|
if (onfulfilledParameterSignatures.length === 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback);
|
|
}
|
|
return void 0;
|
|
}
|
|
return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2 /* Subtype */);
|
|
}
|
|
function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, arg0) {
|
|
const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
|
|
return awaitedType || errorType;
|
|
}
|
|
function isThenableType(type) {
|
|
if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
|
|
return false;
|
|
}
|
|
const thenFunction = getTypeOfPropertyOfType(type, "then");
|
|
return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, 2097152 /* NEUndefinedOrNull */), 0 /* Call */).length > 0;
|
|
}
|
|
function isAwaitedTypeInstantiation(type) {
|
|
var _a2;
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
const awaitedSymbol = getGlobalAwaitedSymbol(false);
|
|
return !!awaitedSymbol && type.aliasSymbol === awaitedSymbol && ((_a2 = type.aliasTypeArguments) == null ? void 0 : _a2.length) === 1;
|
|
}
|
|
return false;
|
|
}
|
|
function unwrapAwaitedType(type) {
|
|
return type.flags & 1048576 /* Union */ ? mapType(type, unwrapAwaitedType) : isAwaitedTypeInstantiation(type) ? type.aliasTypeArguments[0] : type;
|
|
}
|
|
function isAwaitedTypeNeeded(type) {
|
|
if (isTypeAny(type) || isAwaitedTypeInstantiation(type)) {
|
|
return false;
|
|
}
|
|
if (isGenericObjectType(type)) {
|
|
const baseConstraint = getBaseConstraintOfType(type);
|
|
if (baseConstraint ? baseConstraint.flags & 3 /* AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || someType(baseConstraint, isThenableType) : maybeTypeOfKind(type, 8650752 /* TypeVariable */)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function tryCreateAwaitedType(type) {
|
|
const awaitedSymbol = getGlobalAwaitedSymbol(true);
|
|
if (awaitedSymbol) {
|
|
return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
|
|
}
|
|
return void 0;
|
|
}
|
|
function createAwaitedTypeIfNeeded(type) {
|
|
if (isAwaitedTypeNeeded(type)) {
|
|
const awaitedType = tryCreateAwaitedType(type);
|
|
if (awaitedType) {
|
|
return awaitedType;
|
|
}
|
|
}
|
|
Debug.assert(getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
|
|
return type;
|
|
}
|
|
function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
|
|
const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
|
|
return awaitedType && createAwaitedTypeIfNeeded(awaitedType);
|
|
}
|
|
function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0) {
|
|
if (isTypeAny(type)) {
|
|
return type;
|
|
}
|
|
if (isAwaitedTypeInstantiation(type)) {
|
|
return type;
|
|
}
|
|
const typeAsAwaitable = type;
|
|
if (typeAsAwaitable.awaitedTypeOfType) {
|
|
return typeAsAwaitable.awaitedTypeOfType;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
if (awaitedTypeStack.lastIndexOf(type.id) >= 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias;
|
|
awaitedTypeStack.push(type.id);
|
|
const mapped = mapType(type, mapper);
|
|
awaitedTypeStack.pop();
|
|
return typeAsAwaitable.awaitedTypeOfType = mapped;
|
|
}
|
|
if (isAwaitedTypeNeeded(type)) {
|
|
return typeAsAwaitable.awaitedTypeOfType = type;
|
|
}
|
|
const thisTypeForErrorOut = { value: void 0 };
|
|
const promisedType = getPromisedTypeOfPromise(type, void 0, thisTypeForErrorOut);
|
|
if (promisedType) {
|
|
if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
awaitedTypeStack.push(type.id);
|
|
const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, arg0);
|
|
awaitedTypeStack.pop();
|
|
if (!awaitedType) {
|
|
return void 0;
|
|
}
|
|
return typeAsAwaitable.awaitedTypeOfType = awaitedType;
|
|
}
|
|
if (isThenableType(type)) {
|
|
if (errorNode) {
|
|
Debug.assertIsDefined(diagnosticMessage);
|
|
let chain;
|
|
if (thisTypeForErrorOut.value) {
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value));
|
|
}
|
|
chain = chainDiagnosticMessages(chain, diagnosticMessage, arg0);
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(errorNode, chain));
|
|
}
|
|
return void 0;
|
|
}
|
|
return typeAsAwaitable.awaitedTypeOfType = type;
|
|
}
|
|
function checkAsyncFunctionReturnType(node, returnTypeNode) {
|
|
const returnType = getTypeFromTypeNode(returnTypeNode);
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
if (isErrorType(returnType)) {
|
|
return;
|
|
}
|
|
const globalPromiseType = getGlobalPromiseType(true);
|
|
if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) {
|
|
error(returnTypeNode, 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 {
|
|
markTypeNodeAsReferenced(returnTypeNode);
|
|
if (isErrorType(returnType)) {
|
|
return;
|
|
}
|
|
const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
|
|
if (promiseConstructorName === void 0) {
|
|
error(returnTypeNode, 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;
|
|
}
|
|
const promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551 /* Value */, true);
|
|
const promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
|
|
if (isErrorType(promiseConstructorType)) {
|
|
if (promiseConstructorName.kind === 79 /* Identifier */ && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) {
|
|
error(returnTypeNode, 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, 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, entityNameToString(promiseConstructorName));
|
|
}
|
|
return;
|
|
}
|
|
const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(true);
|
|
if (globalPromiseConstructorLikeType === emptyObjectType) {
|
|
error(returnTypeNode, 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, entityNameToString(promiseConstructorName));
|
|
return;
|
|
}
|
|
if (!checkTypeAssignableTo(
|
|
promiseConstructorType,
|
|
globalPromiseConstructorLikeType,
|
|
returnTypeNode,
|
|
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;
|
|
}
|
|
const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
|
|
const collidingSymbol = getSymbol(node.locals, rootName.escapedText, 111551 /* Value */);
|
|
if (collidingSymbol) {
|
|
error(
|
|
collidingSymbol.valueDeclaration,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions,
|
|
idText(rootName),
|
|
entityNameToString(promiseConstructorName)
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
checkAwaitedType(returnType, false, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
}
|
|
function checkDecorator(node) {
|
|
const signature = getResolvedSignature(node);
|
|
checkDeprecatedSignature(signature, node);
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType.flags & 1 /* Any */) {
|
|
return;
|
|
}
|
|
let headMessage;
|
|
let expectedReturnType;
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
|
|
const classSymbol = getSymbolOfNode(node.parent);
|
|
const classConstructorType = getTypeOfSymbol(classSymbol);
|
|
expectedReturnType = getUnionType([classConstructorType, voidType]);
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 166 /* Parameter */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
|
|
expectedReturnType = voidType;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
|
|
const methodType = getTypeOfNode(node.parent);
|
|
const descriptorType = createTypedPropertyDescriptorType(methodType);
|
|
expectedReturnType = getUnionType([descriptorType, voidType]);
|
|
break;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
checkTypeAssignableTo(
|
|
returnType,
|
|
expectedReturnType,
|
|
node,
|
|
headMessage
|
|
);
|
|
}
|
|
function markTypeNodeAsReferenced(node) {
|
|
markEntityNameOrEntityExpressionAsReference(node && getEntityNameFromTypeNode(node), false);
|
|
}
|
|
function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
|
|
if (!typeName)
|
|
return;
|
|
const rootName = getFirstIdentifier(typeName);
|
|
const meaning = (typeName.kind === 79 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
|
|
const rootSymbol = resolveName(rootName, rootName.escapedText, meaning, void 0, void 0, true);
|
|
if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
|
|
if (symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
|
|
markAliasSymbolAsReferenced(rootSymbol);
|
|
} else if (forDecoratorMetadata && compilerOptions.isolatedModules && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
|
|
const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
|
|
const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration);
|
|
if (aliasDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function markDecoratorMedataDataTypeNodeAsReferenced(node) {
|
|
const entityName = getEntityNameForDecoratorMetadata(node);
|
|
if (entityName && isEntityName(entityName)) {
|
|
markEntityNameOrEntityExpressionAsReference(entityName, true);
|
|
}
|
|
}
|
|
function getEntityNameForDecoratorMetadata(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 190 /* IntersectionType */:
|
|
case 189 /* UnionType */:
|
|
return getEntityNameForDecoratorMetadataFromTypeList(node.types);
|
|
case 191 /* ConditionalType */:
|
|
return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
return getEntityNameForDecoratorMetadata(node.type);
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
}
|
|
}
|
|
}
|
|
function getEntityNameForDecoratorMetadataFromTypeList(types) {
|
|
let commonEntityName;
|
|
for (let typeNode of types) {
|
|
while (typeNode.kind === 193 /* ParenthesizedType */ || typeNode.kind === 199 /* NamedTupleMember */) {
|
|
typeNode = typeNode.type;
|
|
}
|
|
if (typeNode.kind === 144 /* NeverKeyword */) {
|
|
continue;
|
|
}
|
|
if (!strictNullChecks && (typeNode.kind === 198 /* LiteralType */ && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
|
|
continue;
|
|
}
|
|
const individualEntityName = getEntityNameForDecoratorMetadata(typeNode);
|
|
if (!individualEntityName) {
|
|
return void 0;
|
|
}
|
|
if (commonEntityName) {
|
|
if (!isIdentifier(commonEntityName) || !isIdentifier(individualEntityName) || commonEntityName.escapedText !== individualEntityName.escapedText) {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
commonEntityName = individualEntityName;
|
|
}
|
|
}
|
|
return commonEntityName;
|
|
}
|
|
function getParameterTypeNodeForDecoratorCheck(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
return isRestParameter(node) ? getRestParameterElementType(typeNode) : typeNode;
|
|
}
|
|
function checkDecorators(node) {
|
|
if (!canHaveDecorators(node) || !hasDecorators(node) || !node.modifiers || !nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
|
|
return;
|
|
}
|
|
if (!compilerOptions.experimentalDecorators) {
|
|
error(node, 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);
|
|
}
|
|
const firstDecorator = find(node.modifiers, isDecorator);
|
|
if (!firstDecorator) {
|
|
return;
|
|
}
|
|
checkExternalEmitHelpers(firstDecorator, 8 /* Decorate */);
|
|
if (node.kind === 166 /* Parameter */) {
|
|
checkExternalEmitHelpers(firstDecorator, 32 /* Param */);
|
|
}
|
|
if (compilerOptions.emitDecoratorMetadata) {
|
|
checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
if (constructor) {
|
|
for (const parameter of constructor.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
}
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const otherKind = node.kind === 174 /* GetAccessor */ ? 175 /* SetAccessor */ : 174 /* GetAccessor */;
|
|
const otherAccessor = getDeclarationOfKind(getSymbolOfNode(node), otherKind);
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
for (const parameter of node.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
|
|
break;
|
|
case 166 /* Parameter */:
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
|
|
const containingSignature = node.parent;
|
|
for (const parameter of containingSignature.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
for (const modifier of node.modifiers) {
|
|
if (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) {
|
|
error(node.name, Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags);
|
|
}
|
|
if (node.name) {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
|
|
}
|
|
checkSourceElement(node.typeExpression);
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
}
|
|
function checkJSDocTemplateTag(node) {
|
|
checkSourceElement(node.constraint);
|
|
for (const tp of node.typeParameters) {
|
|
checkSourceElement(tp);
|
|
}
|
|
}
|
|
function checkJSDocTypeTag(node) {
|
|
checkSourceElement(node.typeExpression);
|
|
}
|
|
function checkJSDocLinkLikeTag(node) {
|
|
if (node.name) {
|
|
resolveJSDocMemberName(node.name, 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 && !isJSDocConstructSignature(node)) {
|
|
reportImplicitAny(node, anyType);
|
|
}
|
|
}
|
|
}
|
|
function checkJSDocImplementsTag(node) {
|
|
const classLike = getEffectiveJSDocHost(node);
|
|
if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
|
|
error(classLike, Diagnostics.JSDoc_0_is_not_attached_to_a_class, idText(node.tagName));
|
|
}
|
|
}
|
|
function checkJSDocAugmentsTag(node) {
|
|
const classLike = getEffectiveJSDocHost(node);
|
|
if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
|
|
error(classLike, Diagnostics.JSDoc_0_is_not_attached_to_a_class, idText(node.tagName));
|
|
return;
|
|
}
|
|
const augmentsTags = getJSDocTags(classLike).filter(isJSDocAugmentsTag);
|
|
Debug.assert(augmentsTags.length > 0);
|
|
if (augmentsTags.length > 1) {
|
|
error(augmentsTags[1], Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag);
|
|
}
|
|
const name = getIdentifierFromEntityNameExpression(node.class.expression);
|
|
const extend2 = getClassExtendsHeritageElement(classLike);
|
|
if (extend2) {
|
|
const className = getIdentifierFromEntityNameExpression(extend2.expression);
|
|
if (className && name.escapedText !== className.escapedText) {
|
|
error(name, Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, idText(node.tagName), idText(name), idText(className));
|
|
}
|
|
}
|
|
}
|
|
function checkJSDocAccessibilityModifiers(node) {
|
|
const host2 = getJSDocHost(node);
|
|
if (host2 && isPrivateIdentifierClassElementDeclaration(host2)) {
|
|
error(node, Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
|
|
}
|
|
}
|
|
function getIdentifierFromEntityNameExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.name;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkFunctionOrMethodDeclaration(node) {
|
|
var _a2;
|
|
checkDecorators(node);
|
|
checkSignatureDeclaration(node);
|
|
const functionFlags = getFunctionFlags(node);
|
|
if (node.name && node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
if (hasBindableName(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const localSymbol = node.localSymbol || symbol;
|
|
const firstDeclaration = (_a2 = localSymbol.declarations) == null ? void 0 : _a2.find(
|
|
(declaration) => declaration.kind === node.kind && !(declaration.flags & 262144 /* JavaScriptFile */)
|
|
);
|
|
if (node === firstDeclaration) {
|
|
checkFunctionOrConstructorSymbol(localSymbol);
|
|
}
|
|
if (symbol.parent) {
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
}
|
|
}
|
|
const body = node.kind === 170 /* MethodSignature */ ? void 0 : node.body;
|
|
checkSourceElement(body);
|
|
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
|
|
addLazyDiagnostic(checkFunctionOrMethodDeclarationDiagnostics);
|
|
if (isInJSFile(node)) {
|
|
const typeTag = getJSDocTypeTag(node);
|
|
if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) {
|
|
error(typeTag.typeExpression.type, Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
|
|
}
|
|
}
|
|
function checkFunctionOrMethodDeclarationDiagnostics() {
|
|
if (!getEffectiveReturnTypeNode(node)) {
|
|
if (nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
|
|
reportImplicitAny(node, anyType);
|
|
}
|
|
if (functionFlags & 1 /* Generator */ && nodeIsPresent(body)) {
|
|
getReturnTypeOfSignature(getSignatureFromDeclaration(node));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function registerForUnusedIdentifiersCheck(node) {
|
|
addLazyDiagnostic(registerForUnusedIdentifiersCheckDiagnostics);
|
|
function registerForUnusedIdentifiersCheckDiagnostics() {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
let potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
|
|
if (!potentiallyUnusedIdentifiers) {
|
|
potentiallyUnusedIdentifiers = [];
|
|
allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers);
|
|
}
|
|
potentiallyUnusedIdentifiers.push(node);
|
|
}
|
|
}
|
|
function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) {
|
|
for (const node of potentiallyUnusedIdentifiers) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
checkUnusedClassMembers(node, addDiagnostic);
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 238 /* Block */:
|
|
case 266 /* CaseBlock */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
checkUnusedLocalsAndParameters(node, addDiagnostic);
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
if (node.body) {
|
|
checkUnusedLocalsAndParameters(node, addDiagnostic);
|
|
}
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 192 /* InferType */:
|
|
checkUnusedInferTypeParameter(node, addDiagnostic);
|
|
break;
|
|
default:
|
|
Debug.assertNever(node, "Node should not have been registered for unused identifiers check");
|
|
}
|
|
}
|
|
}
|
|
function errorUnusedLocal(declaration, name, addDiagnostic) {
|
|
const node = getNameOfDeclaration(declaration) || declaration;
|
|
const message = isTypeDeclaration(declaration) ? Diagnostics._0_is_declared_but_never_used : Diagnostics._0_is_declared_but_its_value_is_never_read;
|
|
addDiagnostic(declaration, 0 /* Local */, createDiagnosticForNode(node, message, name));
|
|
}
|
|
function isIdentifierThatStartsWithUnderscore(node) {
|
|
return isIdentifier(node) && idText(node).charCodeAt(0) === 95 /* _ */;
|
|
}
|
|
function checkUnusedClassMembers(node, addDiagnostic) {
|
|
for (const member of node.members) {
|
|
switch (member.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
if (member.kind === 175 /* SetAccessor */ && member.symbol.flags & 32768 /* GetAccessor */) {
|
|
break;
|
|
}
|
|
const symbol = getSymbolOfNode(member);
|
|
if (!symbol.isReferenced && (hasEffectiveModifier(member, 8 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 16777216 /* Ambient */)) {
|
|
addDiagnostic(member, 0 /* Local */, createDiagnosticForNode(member.name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
for (const parameter of member.parameters) {
|
|
if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 8 /* Private */)) {
|
|
addDiagnostic(parameter, 0 /* Local */, createDiagnosticForNode(parameter.name, Diagnostics.Property_0_is_declared_but_its_value_is_never_read, symbolName(parameter.symbol)));
|
|
}
|
|
}
|
|
break;
|
|
case 178 /* IndexSignature */:
|
|
case 237 /* SemicolonClassElement */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
break;
|
|
default:
|
|
Debug.fail("Unexpected class member");
|
|
}
|
|
}
|
|
}
|
|
function checkUnusedInferTypeParameter(node, addDiagnostic) {
|
|
const { typeParameter } = node;
|
|
if (isTypeParameterUnused(typeParameter)) {
|
|
addDiagnostic(node, 1 /* Parameter */, createDiagnosticForNode(node, Diagnostics._0_is_declared_but_its_value_is_never_read, idText(typeParameter.name)));
|
|
}
|
|
}
|
|
function checkUnusedTypeParameters(node, addDiagnostic) {
|
|
const declarations = getSymbolOfNode(node).declarations;
|
|
if (!declarations || last(declarations) !== node)
|
|
return;
|
|
const typeParameters = getEffectiveTypeParameterDeclarations(node);
|
|
const seenParentsWithEveryUnused = /* @__PURE__ */ new Set();
|
|
for (const typeParameter of typeParameters) {
|
|
if (!isTypeParameterUnused(typeParameter))
|
|
continue;
|
|
const name = idText(typeParameter.name);
|
|
const { parent } = typeParameter;
|
|
if (parent.kind !== 192 /* InferType */ && parent.typeParameters.every(isTypeParameterUnused)) {
|
|
if (tryAddToSet(seenParentsWithEveryUnused, parent)) {
|
|
const sourceFile = getSourceFileOfNode(parent);
|
|
const range = isJSDocTemplateTag(parent) ? rangeOfNode(parent) : rangeOfTypeParameters(sourceFile, parent.typeParameters);
|
|
const only = parent.typeParameters.length === 1;
|
|
const message = only ? Diagnostics._0_is_declared_but_its_value_is_never_read : Diagnostics.All_type_parameters_are_unused;
|
|
const arg0 = only ? name : void 0;
|
|
addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0));
|
|
}
|
|
} else {
|
|
addDiagnostic(typeParameter, 1 /* Parameter */, createDiagnosticForNode(typeParameter, Diagnostics._0_is_declared_but_its_value_is_never_read, name));
|
|
}
|
|
}
|
|
}
|
|
function isTypeParameterUnused(typeParameter) {
|
|
return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144 /* TypeParameter */) && !isIdentifierThatStartsWithUnderscore(typeParameter.name);
|
|
}
|
|
function addToGroup(map2, key, value, getKey) {
|
|
const keyString = String(getKey(key));
|
|
const group2 = map2.get(keyString);
|
|
if (group2) {
|
|
group2[1].push(value);
|
|
} else {
|
|
map2.set(keyString, [key, [value]]);
|
|
}
|
|
}
|
|
function tryGetRootParameterDeclaration(node) {
|
|
return tryCast(getRootDeclaration(node), isParameter);
|
|
}
|
|
function isValidUnusedLocalDeclaration(declaration) {
|
|
if (isBindingElement(declaration)) {
|
|
if (isObjectBindingPattern(declaration.parent)) {
|
|
return !!(declaration.propertyName && isIdentifierThatStartsWithUnderscore(declaration.name));
|
|
}
|
|
return isIdentifierThatStartsWithUnderscore(declaration.name);
|
|
}
|
|
return isAmbientModule(declaration) || (isVariableDeclaration(declaration) && isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name);
|
|
}
|
|
function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) {
|
|
const unusedImports = /* @__PURE__ */ new Map();
|
|
const unusedDestructures = /* @__PURE__ */ new Map();
|
|
const unusedVariables = /* @__PURE__ */ new Map();
|
|
nodeWithLocals.locals.forEach((local) => {
|
|
if (local.flags & 262144 /* TypeParameter */ ? !(local.flags & 3 /* Variable */ && !(local.isReferenced & 3 /* Variable */)) : local.isReferenced || local.exportSymbol) {
|
|
return;
|
|
}
|
|
if (local.declarations) {
|
|
for (const declaration of local.declarations) {
|
|
if (isValidUnusedLocalDeclaration(declaration)) {
|
|
continue;
|
|
}
|
|
if (isImportedDeclaration(declaration)) {
|
|
addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId);
|
|
} else if (isBindingElement(declaration) && isObjectBindingPattern(declaration.parent)) {
|
|
const lastElement = last(declaration.parent.elements);
|
|
if (declaration === lastElement || !last(declaration.parent.elements).dotDotDotToken) {
|
|
addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
|
|
}
|
|
} else if (isVariableDeclaration(declaration)) {
|
|
addToGroup(unusedVariables, declaration.parent, declaration, getNodeId);
|
|
} else {
|
|
const parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration);
|
|
const name = local.valueDeclaration && getNameOfDeclaration(local.valueDeclaration);
|
|
if (parameter && name) {
|
|
if (!isParameterPropertyDeclaration(parameter, parameter.parent) && !parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) {
|
|
if (isBindingElement(declaration) && isArrayBindingPattern(declaration.parent)) {
|
|
addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
|
|
} else {
|
|
addDiagnostic(parameter, 1 /* Parameter */, createDiagnosticForNode(name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolName(local)));
|
|
}
|
|
}
|
|
} else {
|
|
errorUnusedLocal(declaration, symbolName(local), addDiagnostic);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
unusedImports.forEach(([importClause, unuseds]) => {
|
|
const importDecl = importClause.parent;
|
|
const nDeclarations = (importClause.name ? 1 : 0) + (importClause.namedBindings ? importClause.namedBindings.kind === 271 /* NamespaceImport */ ? 1 : importClause.namedBindings.elements.length : 0);
|
|
if (nDeclarations === unuseds.length) {
|
|
addDiagnostic(importDecl, 0 /* Local */, unuseds.length === 1 ? createDiagnosticForNode(importDecl, Diagnostics._0_is_declared_but_its_value_is_never_read, idText(first(unuseds).name)) : createDiagnosticForNode(importDecl, Diagnostics.All_imports_in_import_declaration_are_unused));
|
|
} else {
|
|
for (const unused of unuseds)
|
|
errorUnusedLocal(unused, idText(unused.name), addDiagnostic);
|
|
}
|
|
});
|
|
unusedDestructures.forEach(([bindingPattern, bindingElements]) => {
|
|
const kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 /* Parameter */ : 0 /* Local */;
|
|
if (bindingPattern.elements.length === bindingElements.length) {
|
|
if (bindingElements.length === 1 && bindingPattern.parent.kind === 257 /* VariableDeclaration */ && bindingPattern.parent.parent.kind === 258 /* VariableDeclarationList */) {
|
|
addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId);
|
|
} else {
|
|
addDiagnostic(bindingPattern, kind, bindingElements.length === 1 ? createDiagnosticForNode(bindingPattern, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(first(bindingElements).name)) : createDiagnosticForNode(bindingPattern, Diagnostics.All_destructured_elements_are_unused));
|
|
}
|
|
} else {
|
|
for (const e of bindingElements) {
|
|
addDiagnostic(e, kind, createDiagnosticForNode(e, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name)));
|
|
}
|
|
}
|
|
});
|
|
unusedVariables.forEach(([declarationList, declarations]) => {
|
|
if (declarationList.declarations.length === declarations.length) {
|
|
addDiagnostic(declarationList, 0 /* Local */, declarations.length === 1 ? createDiagnosticForNode(first(declarations).name, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(first(declarations).name)) : createDiagnosticForNode(declarationList.parent.kind === 240 /* VariableStatement */ ? declarationList.parent : declarationList, Diagnostics.All_variables_are_unused));
|
|
} else {
|
|
for (const decl of declarations) {
|
|
addDiagnostic(decl, 0 /* Local */, createDiagnosticForNode(decl, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name)));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function checkPotentialUncheckedRenamedBindingElementsInTypes() {
|
|
var _a2;
|
|
for (const node of potentialUnusedRenamedBindingElementsInTypes) {
|
|
if (!((_a2 = getSymbolOfNode(node)) == null ? void 0 : _a2.isReferenced)) {
|
|
const wrappingDeclaration = walkUpBindingElementsAndPatterns(node);
|
|
Debug.assert(isParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here");
|
|
const diagnostic = createDiagnosticForNode(node.name, Diagnostics._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, declarationNameToString(node.name), declarationNameToString(node.propertyName));
|
|
if (!wrappingDeclaration.type) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createFileDiagnostic(getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, declarationNameToString(node.propertyName))
|
|
);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function bindingNameText(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return idText(name);
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
return bindingNameText(cast(first(name.elements), isBindingElement).name);
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function isImportedDeclaration(node) {
|
|
return node.kind === 270 /* ImportClause */ || node.kind === 273 /* ImportSpecifier */ || node.kind === 271 /* NamespaceImport */;
|
|
}
|
|
function importClauseFromImported(decl) {
|
|
return decl.kind === 270 /* ImportClause */ ? decl : decl.kind === 271 /* NamespaceImport */ ? decl.parent : decl.parent.parent;
|
|
}
|
|
function checkBlock(node) {
|
|
if (node.kind === 238 /* Block */) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
}
|
|
if (isFunctionOrModuleBlock(node)) {
|
|
const saveFlowAnalysisDisabled = flowAnalysisDisabled;
|
|
forEach(node.statements, checkSourceElement);
|
|
flowAnalysisDisabled = saveFlowAnalysisDisabled;
|
|
} else {
|
|
forEach(node.statements, checkSourceElement);
|
|
}
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkCollisionWithArgumentsInGeneratedCode(node) {
|
|
if (languageVersion >= 2 /* ES2015 */ || !hasRestParameter(node) || node.flags & 16777216 /* Ambient */ || nodeIsMissing(node.body)) {
|
|
return;
|
|
}
|
|
forEach(node.parameters, (p) => {
|
|
if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
|
|
errorSkippedOn("noEmit", p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
|
|
}
|
|
});
|
|
}
|
|
function needCollisionCheckForIdentifier(node, identifier, name) {
|
|
if ((identifier == null ? void 0 : identifier.escapedText) !== name) {
|
|
return false;
|
|
}
|
|
if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 168 /* PropertySignature */ || node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */ || node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */ || node.kind === 299 /* PropertyAssignment */) {
|
|
return false;
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return false;
|
|
}
|
|
if (isImportClause(node) || isImportEqualsDeclaration(node) || isImportSpecifier(node)) {
|
|
if (isTypeOnlyImportOrExportDeclaration(node)) {
|
|
return false;
|
|
}
|
|
}
|
|
const root = getRootDeclaration(node);
|
|
if (isParameter(root) && nodeIsMissing(root.parent.body)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function checkIfThisIsCapturedInEnclosingScope(node) {
|
|
findAncestor(node, (current) => {
|
|
if (getNodeCheckFlags(current) & 4 /* CaptureThis */) {
|
|
const isDeclaration2 = node.kind !== 79 /* Identifier */;
|
|
if (isDeclaration2) {
|
|
error(getNameOfDeclaration(node), Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
|
|
} else {
|
|
error(node, Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function checkIfNewTargetIsCapturedInEnclosingScope(node) {
|
|
findAncestor(node, (current) => {
|
|
if (getNodeCheckFlags(current) & 8 /* CaptureNewTarget */) {
|
|
const isDeclaration2 = node.kind !== 79 /* Identifier */;
|
|
if (isDeclaration2) {
|
|
error(getNameOfDeclaration(node), Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference);
|
|
} else {
|
|
error(node, 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) {
|
|
if (moduleKind >= 5 /* ES2015 */ && !(moduleKind >= 100 /* Node16 */ && getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
return;
|
|
}
|
|
if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
|
|
return;
|
|
}
|
|
if (isModuleDeclaration(node) && getModuleInstanceState(node) !== 1 /* Instantiated */) {
|
|
return;
|
|
}
|
|
const parent = getDeclarationContainer(node);
|
|
if (parent.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(parent)) {
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
name,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,
|
|
declarationNameToString(name),
|
|
declarationNameToString(name)
|
|
);
|
|
}
|
|
}
|
|
function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) {
|
|
if (!name || languageVersion >= 4 /* ES2017 */ || !needCollisionCheckForIdentifier(node, name, "Promise")) {
|
|
return;
|
|
}
|
|
if (isModuleDeclaration(node) && getModuleInstanceState(node) !== 1 /* Instantiated */) {
|
|
return;
|
|
}
|
|
const parent = getDeclarationContainer(node);
|
|
if (parent.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(parent) && parent.flags & 2048 /* HasAsyncFunctions */) {
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
name,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,
|
|
declarationNameToString(name),
|
|
declarationNameToString(name)
|
|
);
|
|
}
|
|
}
|
|
function recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name) {
|
|
if (languageVersion <= 8 /* ES2021 */ && (needCollisionCheckForIdentifier(node, name, "WeakMap") || needCollisionCheckForIdentifier(node, name, "WeakSet"))) {
|
|
potentialWeakMapSetCollisions.push(node);
|
|
}
|
|
}
|
|
function checkWeakMapSetCollision(node) {
|
|
const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
|
|
if (getNodeCheckFlags(enclosingBlockScope) & 4194304 /* ContainsClassWithPrivateIdentifiers */) {
|
|
Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier");
|
|
errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText);
|
|
}
|
|
}
|
|
function recordPotentialCollisionWithReflectInGeneratedCode(node, name) {
|
|
if (name && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && needCollisionCheckForIdentifier(node, name, "Reflect")) {
|
|
potentialReflectCollisions.push(node);
|
|
}
|
|
}
|
|
function checkReflectCollision(node) {
|
|
let hasCollision = false;
|
|
if (isClassExpression(node)) {
|
|
for (const member of node.members) {
|
|
if (getNodeCheckFlags(member) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
break;
|
|
}
|
|
}
|
|
} else if (isFunctionExpression(node)) {
|
|
if (getNodeCheckFlags(node) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
}
|
|
} else {
|
|
const container = getEnclosingBlockScopeContainer(node);
|
|
if (container && getNodeCheckFlags(container) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
}
|
|
}
|
|
if (hasCollision) {
|
|
Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name), "The target of a Reflect collision check should be an identifier");
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
node,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers,
|
|
declarationNameToString(node.name),
|
|
"Reflect"
|
|
);
|
|
}
|
|
}
|
|
function checkCollisionsForDeclarationName(node, name) {
|
|
if (!name)
|
|
return;
|
|
checkCollisionWithRequireExportsInGeneratedCode(node, name);
|
|
checkCollisionWithGlobalPromiseInGeneratedCode(node, name);
|
|
recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name);
|
|
recordPotentialCollisionWithReflectInGeneratedCode(node, name);
|
|
if (isClassLike(node)) {
|
|
checkTypeNameIsReserved(name, Diagnostics.Class_name_cannot_be_0);
|
|
if (!(node.flags & 16777216 /* Ambient */)) {
|
|
checkClassNameCollisionWithObject(name);
|
|
}
|
|
} else if (isEnumDeclaration(node)) {
|
|
checkTypeNameIsReserved(name, Diagnostics.Enum_name_cannot_be_0);
|
|
}
|
|
}
|
|
function checkVarDeclaredNamesNotShadowed(node) {
|
|
if ((getCombinedNodeFlags(node) & 3 /* BlockScoped */) !== 0 || isParameterDeclaration(node)) {
|
|
return;
|
|
}
|
|
if (node.kind === 257 /* VariableDeclaration */ && !node.initializer) {
|
|
return;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 1 /* FunctionScopedVariable */) {
|
|
if (!isIdentifier(node.name))
|
|
return Debug.fail();
|
|
const localDeclarationSymbol = resolveName(node, node.name.escapedText, 3 /* Variable */, void 0, void 0, false);
|
|
if (localDeclarationSymbol && localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) {
|
|
if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3 /* BlockScoped */) {
|
|
const varDeclList = getAncestor(localDeclarationSymbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
const container = varDeclList.parent.kind === 240 /* VariableStatement */ && varDeclList.parent.parent ? varDeclList.parent.parent : void 0;
|
|
const namesShareScope = container && (container.kind === 238 /* Block */ && isFunctionLike(container.parent) || container.kind === 265 /* ModuleBlock */ || container.kind === 264 /* ModuleDeclaration */ || container.kind === 308 /* SourceFile */);
|
|
if (!namesShareScope) {
|
|
const name = symbolToString(localDeclarationSymbol);
|
|
error(node, 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;
|
|
}
|
|
function checkVariableLikeDeclaration(node) {
|
|
var _a2;
|
|
checkDecorators(node);
|
|
if (!isBindingElement(node)) {
|
|
checkSourceElement(node.type);
|
|
}
|
|
if (!node.name) {
|
|
return;
|
|
}
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
if (hasOnlyExpressionInitializer(node) && node.initializer) {
|
|
checkExpressionCached(node.initializer);
|
|
}
|
|
}
|
|
if (isBindingElement(node)) {
|
|
if (node.propertyName && isIdentifier(node.name) && isParameterDeclaration(node) && nodeIsMissing(getContainingFunction(node).body)) {
|
|
potentialUnusedRenamedBindingElementsInTypes.push(node);
|
|
return;
|
|
}
|
|
if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
|
|
checkExternalEmitHelpers(node, 4 /* Rest */);
|
|
}
|
|
if (node.propertyName && node.propertyName.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.propertyName);
|
|
}
|
|
const parent = node.parent.parent;
|
|
const parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
|
|
const parentType = getTypeForBindingElementParent(parent, parentCheckMode);
|
|
const name = node.propertyName || node.name;
|
|
if (parentType && !isBindingPattern(name)) {
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(exprType)) {
|
|
const nameText = getPropertyNameFromType(exprType);
|
|
const property = getPropertyOfType(parentType, nameText);
|
|
if (property) {
|
|
markPropertyAsReferenced(property, void 0, false);
|
|
checkPropertyAccessibility(node, !!parent.initializer && parent.initializer.kind === 106 /* SuperKeyword */, false, parentType, property);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
if (node.name.kind === 204 /* ArrayBindingPattern */ && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 512 /* Read */);
|
|
}
|
|
forEach(node.name.elements, checkSourceElement);
|
|
}
|
|
if (isParameter(node) && node.initializer && nodeIsMissing(getContainingFunction(node).body)) {
|
|
error(node, Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
|
|
return;
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
const needCheckInitializer = hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* ForInStatement */;
|
|
const needCheckWidenedType = !some(node.name.elements, not(isOmittedExpression));
|
|
if (needCheckInitializer || needCheckWidenedType) {
|
|
const widenedType = getWidenedTypeForVariableLikeDeclaration(node);
|
|
if (needCheckInitializer) {
|
|
const initializerType = checkExpressionCached(node.initializer);
|
|
if (strictNullChecks && needCheckWidenedType) {
|
|
checkNonNullNonVoidType(initializerType, node);
|
|
} else {
|
|
checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer);
|
|
}
|
|
}
|
|
if (needCheckWidenedType) {
|
|
if (isArrayBindingPattern(node.name)) {
|
|
checkIteratedTypeOrElementType(65 /* Destructuring */, widenedType, undefinedType, node);
|
|
} else if (strictNullChecks) {
|
|
checkNonNullNonVoidType(widenedType, node);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 2097152 /* Alias */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node.kind === 205 /* BindingElement */ ? node.parent.parent : node)) {
|
|
checkAliasSymbol(node);
|
|
return;
|
|
}
|
|
const type = convertAutoToAny(getTypeOfSymbol(symbol));
|
|
if (node === symbol.valueDeclaration) {
|
|
const initializer = hasOnlyExpressionInitializer(node) && getEffectiveInitializer(node);
|
|
if (initializer) {
|
|
const isJSObjectLiteralInitializer = isInJSFile(node) && isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAccess(node.name)) && !!((_a2 = symbol.exports) == null ? void 0 : _a2.size);
|
|
if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 246 /* ForInStatement */) {
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, void 0);
|
|
}
|
|
}
|
|
if (symbol.declarations && symbol.declarations.length > 1) {
|
|
if (some(symbol.declarations, (d) => d !== node && isVariableLike(d) && !areDeclarationFlagsIdentical(d, node))) {
|
|
error(node.name, Diagnostics.All_declarations_of_0_must_have_identical_modifiers, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
} else {
|
|
const declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
|
|
if (!isErrorType(type) && !isErrorType(declarationType) && !isTypeIdenticalTo(type, declarationType) && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
|
|
}
|
|
if (hasOnlyExpressionInitializer(node) && node.initializer) {
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, void 0);
|
|
}
|
|
if (symbol.valueDeclaration && !areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
|
|
error(node.name, Diagnostics.All_declarations_of_0_must_have_identical_modifiers, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
if (node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 168 /* PropertySignature */) {
|
|
checkExportsOnMergedDeclarations(node);
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
checkVarDeclaredNamesNotShadowed(node);
|
|
}
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
}
|
|
function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) {
|
|
const nextDeclarationName = getNameOfDeclaration(nextDeclaration);
|
|
const message = nextDeclaration.kind === 169 /* PropertyDeclaration */ || nextDeclaration.kind === 168 /* PropertySignature */ ? Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 : Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2;
|
|
const declName = declarationNameToString(nextDeclarationName);
|
|
const err = error(
|
|
nextDeclarationName,
|
|
message,
|
|
declName,
|
|
typeToString(firstType),
|
|
typeToString(nextType)
|
|
);
|
|
if (firstDeclaration) {
|
|
addRelatedInfo(
|
|
err,
|
|
createDiagnosticForNode(firstDeclaration, Diagnostics._0_was_also_declared_here, declName)
|
|
);
|
|
}
|
|
}
|
|
function areDeclarationFlagsIdentical(left, right) {
|
|
if (left.kind === 166 /* Parameter */ && right.kind === 257 /* VariableDeclaration */ || left.kind === 257 /* VariableDeclaration */ && right.kind === 166 /* Parameter */) {
|
|
return true;
|
|
}
|
|
if (hasQuestionToken(left) !== hasQuestionToken(right)) {
|
|
return false;
|
|
}
|
|
const interestingFlags = 8 /* Private */ | 16 /* Protected */ | 512 /* Async */ | 256 /* Abstract */ | 64 /* Readonly */ | 32 /* Static */;
|
|
return getSelectedEffectiveModifierFlags(left, interestingFlags) === getSelectedEffectiveModifierFlags(right, interestingFlags);
|
|
}
|
|
function checkVariableDeclaration(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
checkGrammarVariableDeclaration(node);
|
|
checkVariableLikeDeclaration(node);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function checkBindingElement(node) {
|
|
checkGrammarBindingElement(node);
|
|
return checkVariableLikeDeclaration(node);
|
|
}
|
|
function checkVariableStatement(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList))
|
|
checkGrammarForDisallowedLetOrConstStatement(node);
|
|
forEach(node.declarationList.declarations, checkSourceElement);
|
|
}
|
|
function checkExpressionStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkExpression(node.expression);
|
|
}
|
|
function checkIfStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
const type = checkTruthinessExpression(node.expression);
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.expression, type, node.thenStatement);
|
|
checkSourceElement(node.thenStatement);
|
|
if (node.thenStatement.kind === 239 /* EmptyStatement */) {
|
|
error(node.thenStatement, 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 (isBinaryExpression(condExpr) && condExpr.operatorToken.kind === 56 /* BarBarToken */) {
|
|
condExpr = condExpr.left;
|
|
helper(condExpr, body);
|
|
}
|
|
function helper(condExpr2, body2) {
|
|
const location = isBinaryExpression(condExpr2) && (condExpr2.operatorToken.kind === 56 /* BarBarToken */ || condExpr2.operatorToken.kind === 55 /* AmpersandAmpersandToken */) ? condExpr2.right : condExpr2;
|
|
if (isModuleExportsAccessExpression(location))
|
|
return;
|
|
const type = location === condExpr2 ? condType : checkTruthinessExpression(location);
|
|
const isPropertyExpressionCast = isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
|
|
if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
|
|
return;
|
|
const callSignatures = getSignaturesOfType(type, 0 /* Call */);
|
|
const isPromise = !!getAwaitedTypeOfPromise(type);
|
|
if (callSignatures.length === 0 && !isPromise) {
|
|
return;
|
|
}
|
|
const testedNode = isIdentifier(location) ? location : isPropertyAccessExpression(location) ? location.name : isBinaryExpression(location) && isIdentifier(location.right) ? location.right : void 0;
|
|
const testedSymbol = testedNode && getSymbolAtLocation(testedNode);
|
|
if (!testedSymbol && !isPromise) {
|
|
return;
|
|
}
|
|
const isUsed = testedSymbol && isBinaryExpression(condExpr2.parent) && isSymbolUsedInBinaryExpressionChain(condExpr2.parent, testedSymbol) || testedSymbol && body2 && isSymbolUsedInConditionBody(condExpr2, body2, testedNode, testedSymbol);
|
|
if (!isUsed) {
|
|
if (isPromise) {
|
|
errorAndMaybeSuggestAwait(
|
|
location,
|
|
true,
|
|
Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined,
|
|
getTypeNameForErrorDisplay(type)
|
|
);
|
|
} else {
|
|
error(location, 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 !!forEachChild(body, function check(childNode) {
|
|
if (isIdentifier(childNode)) {
|
|
const childSymbol = getSymbolAtLocation(childNode);
|
|
if (childSymbol && childSymbol === testedSymbol) {
|
|
if (isIdentifier(expr) || isIdentifier(testedNode) && isBinaryExpression(testedNode.parent)) {
|
|
return true;
|
|
}
|
|
let testedExpression = testedNode.parent;
|
|
let childExpression = childNode.parent;
|
|
while (testedExpression && childExpression) {
|
|
if (isIdentifier(testedExpression) && isIdentifier(childExpression) || testedExpression.kind === 108 /* ThisKeyword */ && childExpression.kind === 108 /* ThisKeyword */) {
|
|
return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression);
|
|
} else if (isPropertyAccessExpression(testedExpression) && isPropertyAccessExpression(childExpression)) {
|
|
if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) {
|
|
return false;
|
|
}
|
|
childExpression = childExpression.expression;
|
|
testedExpression = testedExpression.expression;
|
|
} else if (isCallExpression(testedExpression) && isCallExpression(childExpression)) {
|
|
childExpression = childExpression.expression;
|
|
testedExpression = testedExpression.expression;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return forEachChild(childNode, check);
|
|
});
|
|
}
|
|
function isSymbolUsedInBinaryExpressionChain(node, testedSymbol) {
|
|
while (isBinaryExpression(node) && node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
const isUsed = forEachChild(node.right, function visit(child) {
|
|
if (isIdentifier(child)) {
|
|
const symbol = getSymbolAtLocation(child);
|
|
if (symbol && symbol === testedSymbol) {
|
|
return true;
|
|
}
|
|
}
|
|
return forEachChild(child, visit);
|
|
});
|
|
if (isUsed) {
|
|
return true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function checkDoStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkSourceElement(node.statement);
|
|
checkTruthinessExpression(node.expression);
|
|
}
|
|
function checkWhileStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkTruthinessExpression(node.expression);
|
|
checkSourceElement(node.statement);
|
|
}
|
|
function checkTruthinessOfType(type, node) {
|
|
if (type.flags & 16384 /* Void */) {
|
|
error(node, 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) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (node.initializer && node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
checkGrammarVariableDeclarationList(node.initializer);
|
|
}
|
|
}
|
|
if (node.initializer) {
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
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);
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (node.awaitModifier) {
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
grammarErrorOnNode(node.awaitModifier, Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block);
|
|
} else {
|
|
const functionFlags = getFunctionFlags(container);
|
|
if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */);
|
|
}
|
|
}
|
|
} else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 256 /* ForOfIncludes */);
|
|
}
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
checkForInOrForOfVariableDeclaration(node);
|
|
} else {
|
|
const varExpr = node.initializer;
|
|
const iteratedType = checkRightHandSideOfForOf(node);
|
|
if (varExpr.kind === 206 /* ArrayLiteralExpression */ || varExpr.kind === 207 /* ObjectLiteralExpression */) {
|
|
checkDestructuringAssignment(varExpr, iteratedType || errorType);
|
|
} else {
|
|
const leftType = checkExpression(varExpr);
|
|
checkReferenceExpression(
|
|
varExpr,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access
|
|
);
|
|
if (iteratedType) {
|
|
checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression);
|
|
}
|
|
}
|
|
}
|
|
checkSourceElement(node.statement);
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkForInStatement(node) {
|
|
checkGrammarForInOrForOfStatement(node);
|
|
const rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression));
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variable = node.initializer.declarations[0];
|
|
if (variable && isBindingPattern(variable.name)) {
|
|
error(variable.name, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
|
|
}
|
|
checkForInOrForOfVariableDeclaration(node);
|
|
} else {
|
|
const varExpr = node.initializer;
|
|
const leftType = checkExpression(varExpr);
|
|
if (varExpr.kind === 206 /* ArrayLiteralExpression */ || varExpr.kind === 207 /* ObjectLiteralExpression */) {
|
|
error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
|
|
} else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) {
|
|
error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
|
|
} else {
|
|
checkReferenceExpression(
|
|
varExpr,
|
|
Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access
|
|
);
|
|
}
|
|
}
|
|
if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
error(node.expression, 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) {
|
|
const variableDeclarationList = iterationStatement.initializer;
|
|
if (variableDeclarationList.declarations.length >= 1) {
|
|
const decl = variableDeclarationList.declarations[0];
|
|
checkVariableDeclaration(decl);
|
|
}
|
|
}
|
|
function checkRightHandSideOfForOf(statement) {
|
|
const use = statement.awaitModifier ? 15 /* ForAwaitOf */ : 13 /* 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, true) || anyType;
|
|
}
|
|
function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
|
|
const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
|
|
if (inputType === neverType) {
|
|
reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
|
|
return void 0;
|
|
}
|
|
const uplevelIteration = languageVersion >= 2 /* ES2015 */;
|
|
const downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration;
|
|
const possibleOutOfBounds = compilerOptions.noUncheckedIndexedAccess && !!(use & 128 /* PossiblyOutOfBounds */);
|
|
if (uplevelIteration || downlevelIteration || allowAsyncIterables) {
|
|
const iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : void 0);
|
|
if (checkAssignability) {
|
|
if (iterationTypes) {
|
|
const diagnostic = use & 8 /* ForOfFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 : use & 32 /* SpreadFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 : use & 64 /* DestructuringFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 : use & 16 /* YieldStarFlag */ ? Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 : void 0;
|
|
if (diagnostic) {
|
|
checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic);
|
|
}
|
|
}
|
|
}
|
|
if (iterationTypes || uplevelIteration) {
|
|
return possibleOutOfBounds ? includeUndefinedInIndexSignature(iterationTypes && iterationTypes.yieldType) : iterationTypes && iterationTypes.yieldType;
|
|
}
|
|
}
|
|
let arrayType = inputType;
|
|
let reportedError = false;
|
|
let hasStringConstituent = false;
|
|
if (use & 4 /* AllowsStringInputFlag */) {
|
|
if (arrayType.flags & 1048576 /* Union */) {
|
|
const arrayTypes = inputType.types;
|
|
const filteredTypes = filter(arrayTypes, (t) => !(t.flags & 402653316 /* StringLike */));
|
|
if (filteredTypes !== arrayTypes) {
|
|
arrayType = getUnionType(filteredTypes, 2 /* Subtype */);
|
|
}
|
|
} else if (arrayType.flags & 402653316 /* StringLike */) {
|
|
arrayType = neverType;
|
|
}
|
|
hasStringConstituent = arrayType !== inputType;
|
|
if (hasStringConstituent) {
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
|
|
reportedError = true;
|
|
}
|
|
}
|
|
if (arrayType.flags & 131072 /* Never */) {
|
|
return possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType;
|
|
}
|
|
}
|
|
}
|
|
if (!isArrayLikeType(arrayType)) {
|
|
if (errorNode && !reportedError) {
|
|
const allowsStrings = !!(use & 4 /* AllowsStringInputFlag */) && !hasStringConstituent;
|
|
const [defaultDiagnostic, maybeMissingAwait] = getIterationDiagnosticDetails(allowsStrings, downlevelIteration);
|
|
errorAndMaybeSuggestAwait(
|
|
errorNode,
|
|
maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType),
|
|
defaultDiagnostic,
|
|
typeToString(arrayType)
|
|
);
|
|
}
|
|
return hasStringConstituent ? possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType : void 0;
|
|
}
|
|
const arrayElementType = getIndexTypeOfType(arrayType, numberType);
|
|
if (hasStringConstituent && arrayElementType) {
|
|
if (arrayElementType.flags & 402653316 /* StringLike */ && !compilerOptions.noUncheckedIndexedAccess) {
|
|
return stringType;
|
|
}
|
|
return getUnionType(possibleOutOfBounds ? [arrayElementType, stringType, undefinedType] : [arrayElementType, stringType], 2 /* Subtype */);
|
|
}
|
|
return use & 128 /* PossiblyOutOfBounds */ ? includeUndefinedInIndexSignature(arrayElementType) : arrayElementType;
|
|
function getIterationDiagnosticDetails(allowsStrings, downlevelIteration2) {
|
|
var _a2;
|
|
if (downlevelIteration2) {
|
|
return allowsStrings ? [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] : [Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true];
|
|
}
|
|
const yieldType = getIterationTypeOfIterable(use, 0 /* Yield */, inputType, void 0);
|
|
if (yieldType) {
|
|
return [Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false];
|
|
}
|
|
if (isES2015OrLaterIterable((_a2 = inputType.symbol) == null ? void 0 : _a2.escapedName)) {
|
|
return [Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true];
|
|
}
|
|
return allowsStrings ? [Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true] : [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;
|
|
}
|
|
function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) {
|
|
if (isTypeAny(inputType)) {
|
|
return void 0;
|
|
}
|
|
const iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode);
|
|
return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
|
|
}
|
|
function createIterationTypes(yieldType = neverType, returnType = neverType, nextType = unknownType) {
|
|
if (yieldType.flags & 67359327 /* Intrinsic */ && returnType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */) && nextType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */)) {
|
|
const id = getTypeListId([yieldType, returnType, nextType]);
|
|
let iterationTypes = iterationTypesCache.get(id);
|
|
if (!iterationTypes) {
|
|
iterationTypes = { yieldType, returnType, nextType };
|
|
iterationTypesCache.set(id, iterationTypes);
|
|
}
|
|
return iterationTypes;
|
|
}
|
|
return { yieldType, returnType, nextType };
|
|
}
|
|
function combineIterationTypes(array) {
|
|
let yieldTypes;
|
|
let returnTypes;
|
|
let nextTypes;
|
|
for (const iterationTypes of array) {
|
|
if (iterationTypes === void 0 || iterationTypes === noIterationTypes) {
|
|
continue;
|
|
}
|
|
if (iterationTypes === anyIterationTypes) {
|
|
return anyIterationTypes;
|
|
}
|
|
yieldTypes = append(yieldTypes, iterationTypes.yieldType);
|
|
returnTypes = append(returnTypes, iterationTypes.returnType);
|
|
nextTypes = 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, cachedTypes2) {
|
|
return type[cacheKey] = cachedTypes2;
|
|
}
|
|
function getIterationTypesOfIterable(type, use, errorNode) {
|
|
var _a2, _b;
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
|
|
const iterationTypes2 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer);
|
|
if (iterationTypes2 === noIterationTypes) {
|
|
if (errorNode) {
|
|
const rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
|
|
if (errorOutputContainer == null ? void 0 : errorOutputContainer.errors) {
|
|
addRelatedInfo(rootDiag, ...errorOutputContainer.errors);
|
|
}
|
|
}
|
|
return void 0;
|
|
} else if ((_a2 = errorOutputContainer == null ? void 0 : errorOutputContainer.errors) == null ? void 0 : _a2.length) {
|
|
for (const diag2 of errorOutputContainer.errors) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
return iterationTypes2;
|
|
}
|
|
const cacheKey = use & 2 /* AllowsAsyncIterablesFlag */ ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
|
|
const cachedTypes2 = getCachedIterationTypes(type, cacheKey);
|
|
if (cachedTypes2)
|
|
return cachedTypes2 === noIterationTypes ? void 0 : cachedTypes2;
|
|
let allIterationTypes;
|
|
for (const constituent of type.types) {
|
|
const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
|
|
const iterationTypes2 = getIterationTypesOfIterableWorker(constituent, use, errorNode, errorOutputContainer);
|
|
if (iterationTypes2 === noIterationTypes) {
|
|
if (errorNode) {
|
|
const rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
|
|
if (errorOutputContainer == null ? void 0 : errorOutputContainer.errors) {
|
|
addRelatedInfo(rootDiag, ...errorOutputContainer.errors);
|
|
}
|
|
}
|
|
setCachedIterationTypes(type, cacheKey, noIterationTypes);
|
|
return void 0;
|
|
} else if ((_b = errorOutputContainer == null ? void 0 : errorOutputContainer.errors) == null ? void 0 : _b.length) {
|
|
for (const diag2 of errorOutputContainer.errors) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
allIterationTypes = append(allIterationTypes, iterationTypes2);
|
|
}
|
|
const iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
|
|
setCachedIterationTypes(type, cacheKey, iterationTypes);
|
|
return iterationTypes === noIterationTypes ? void 0 : iterationTypes;
|
|
}
|
|
function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) {
|
|
if (iterationTypes === noIterationTypes)
|
|
return noIterationTypes;
|
|
if (iterationTypes === anyIterationTypes)
|
|
return anyIterationTypes;
|
|
const { yieldType, returnType, nextType } = iterationTypes;
|
|
if (errorNode) {
|
|
getGlobalAwaitedSymbol(true);
|
|
}
|
|
return createIterationTypes(
|
|
getAwaitedType(yieldType, errorNode) || anyType,
|
|
getAwaitedType(returnType, errorNode) || anyType,
|
|
nextType
|
|
);
|
|
}
|
|
function getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
let noCache = false;
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
const iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
|
|
if (iterationTypes) {
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
noCache = true;
|
|
} else {
|
|
return use & 8 /* ForOfFlag */ ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode) : iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
if (use & 1 /* AllowsSyncIterablesFlag */) {
|
|
let iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) || getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
|
|
if (iterationTypes) {
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
noCache = true;
|
|
} else {
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
if (iterationTypes !== noIterationTypes) {
|
|
iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
|
|
}
|
|
} else {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
const iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
|
|
if (iterationTypes !== noIterationTypes) {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
if (use & 1 /* AllowsSyncIterablesFlag */) {
|
|
let iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
|
|
if (iterationTypes !== noIterationTypes) {
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
|
|
} else {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
return noIterationTypes;
|
|
}
|
|
function getIterationTypesOfIterableCached(type, resolver) {
|
|
return getCachedIterationTypes(type, resolver.iterableCacheKey);
|
|
}
|
|
function getIterationTypesOfGlobalIterableType(globalType, resolver) {
|
|
const globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || getIterationTypesOfIterableSlow(globalType, resolver, void 0, void 0, false);
|
|
return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
|
|
}
|
|
function getIterationTypesOfIterableFast(type, resolver) {
|
|
let globalType;
|
|
if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(false)) || isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(false))) {
|
|
const [yieldType] = getTypeArguments(type);
|
|
const { returnType, nextType } = getIterationTypesOfGlobalIterableType(globalType, resolver);
|
|
return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, void 0) || yieldType, resolver.resolveIterationType(returnType, void 0) || returnType, nextType));
|
|
}
|
|
if (isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
|
|
const [yieldType, returnType, nextType] = getTypeArguments(type);
|
|
return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, void 0) || yieldType, resolver.resolveIterationType(returnType, void 0) || returnType, nextType));
|
|
}
|
|
}
|
|
function getPropertyNameForKnownSymbolName(symbolName2) {
|
|
const ctorType = getGlobalESSymbolConstructorSymbol(false);
|
|
const uniqueType = ctorType && getTypeOfPropertyOfType(getTypeOfSymbol(ctorType), escapeLeadingUnderscores(symbolName2));
|
|
return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : `__@${symbolName2}`;
|
|
}
|
|
function getIterationTypesOfIterableSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
var _a2;
|
|
const method = getPropertyOfType(type, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
|
|
const methodType = method && !(method.flags & 16777216 /* Optional */) ? getTypeOfSymbol(method) : void 0;
|
|
if (isTypeAny(methodType)) {
|
|
return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
|
|
}
|
|
const signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
|
|
if (!some(signatures)) {
|
|
return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
|
|
}
|
|
const iteratorType = getIntersectionType(map(signatures, getReturnTypeOfSignature));
|
|
const iterationTypes = (_a2 = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache)) != null ? _a2 : noIterationTypes;
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
|
|
}
|
|
function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) {
|
|
const message = allowAsyncIterables ? Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator : Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
|
|
const suggestAwait = !!getAwaitedTypeOfPromise(type) || !allowAsyncIterables && isForOfStatement(errorNode.parent) && errorNode.parent.expression === errorNode && getGlobalAsyncIterableType(false) !== emptyGenericType && isTypeAssignableTo(
|
|
type,
|
|
getGlobalAsyncIterableType(false)
|
|
);
|
|
return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
|
|
}
|
|
function getIterationTypesOfIterator(type, resolver, errorNode, errorOutputContainer) {
|
|
return getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, false);
|
|
}
|
|
function getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
let iterationTypes = getIterationTypesOfIteratorCached(type, resolver) || getIterationTypesOfIteratorFast(type, resolver);
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
iterationTypes = void 0;
|
|
noCache = true;
|
|
}
|
|
iterationTypes != null ? iterationTypes : iterationTypes = getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache);
|
|
return iterationTypes === noIterationTypes ? void 0 : iterationTypes;
|
|
}
|
|
function getIterationTypesOfIteratorCached(type, resolver) {
|
|
return getCachedIterationTypes(type, resolver.iteratorCacheKey);
|
|
}
|
|
function getIterationTypesOfIteratorFast(type, resolver) {
|
|
const globalType = resolver.getGlobalIterableIteratorType(false);
|
|
if (isReferenceToType(type, globalType)) {
|
|
const [yieldType] = getTypeArguments(type);
|
|
const globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || getIterationTypesOfIteratorSlow(globalType, resolver, void 0, void 0, false);
|
|
const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
|
|
return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
|
|
}
|
|
if (isReferenceToType(type, resolver.getGlobalIteratorType(false)) || isReferenceToType(type, resolver.getGlobalGeneratorType(false))) {
|
|
const [yieldType, returnType, nextType] = getTypeArguments(type);
|
|
return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
|
|
}
|
|
}
|
|
function isIteratorResult(type, kind) {
|
|
const doneType = getTypeOfPropertyOfType(type, "done") || falseType;
|
|
return isTypeAssignableTo(kind === 0 /* Yield */ ? falseType : trueType, doneType);
|
|
}
|
|
function isYieldIteratorResult(type) {
|
|
return isIteratorResult(type, 0 /* Yield */);
|
|
}
|
|
function isReturnIteratorResult(type) {
|
|
return isIteratorResult(type, 1 /* Return */);
|
|
}
|
|
function getIterationTypesOfIteratorResult(type) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
const cachedTypes2 = getCachedIterationTypes(type, "iterationTypesOfIteratorResult");
|
|
if (cachedTypes2) {
|
|
return cachedTypes2;
|
|
}
|
|
if (isReferenceToType(type, getGlobalIteratorYieldResultType(false))) {
|
|
const yieldType2 = getTypeArguments(type)[0];
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType2, void 0, void 0));
|
|
}
|
|
if (isReferenceToType(type, getGlobalIteratorReturnResultType(false))) {
|
|
const returnType2 = getTypeArguments(type)[0];
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(void 0, returnType2, void 0));
|
|
}
|
|
const yieldIteratorResult = filterType(type, isYieldIteratorResult);
|
|
const yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : void 0;
|
|
const returnIteratorResult = filterType(type, isReturnIteratorResult);
|
|
const returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : void 0;
|
|
if (!yieldType && !returnType) {
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes);
|
|
}
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, void 0));
|
|
}
|
|
function getIterationTypesOfMethod(type, resolver, methodName, errorNode, errorOutputContainer) {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
const method = getPropertyOfType(type, methodName);
|
|
if (!method && methodName !== "next") {
|
|
return void 0;
|
|
}
|
|
const methodType = method && !(methodName === "next" && method.flags & 16777216 /* Optional */) ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152 /* NEUndefinedOrNull */) : void 0;
|
|
if (isTypeAny(methodType)) {
|
|
return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
|
|
}
|
|
const methodSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : emptyArray;
|
|
if (methodSignatures.length === 0) {
|
|
if (errorNode) {
|
|
const diagnostic = methodName === "next" ? resolver.mustHaveANextMethodDiagnostic : resolver.mustBeAMethodDiagnostic;
|
|
if (errorOutputContainer) {
|
|
(_a2 = errorOutputContainer.errors) != null ? _a2 : errorOutputContainer.errors = [];
|
|
errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, diagnostic, methodName));
|
|
} else {
|
|
error(errorNode, diagnostic, methodName);
|
|
}
|
|
}
|
|
return methodName === "next" ? noIterationTypes : void 0;
|
|
}
|
|
if ((methodType == null ? void 0 : methodType.symbol) && methodSignatures.length === 1) {
|
|
const globalGeneratorType = resolver.getGlobalGeneratorType(false);
|
|
const globalIteratorType = resolver.getGlobalIteratorType(false);
|
|
const isGeneratorMethod = ((_c = (_b = globalGeneratorType.symbol) == null ? void 0 : _b.members) == null ? void 0 : _c.get(methodName)) === methodType.symbol;
|
|
const isIteratorMethod = !isGeneratorMethod && ((_e = (_d = globalIteratorType.symbol) == null ? void 0 : _d.members) == null ? void 0 : _e.get(methodName)) === methodType.symbol;
|
|
if (isGeneratorMethod || isIteratorMethod) {
|
|
const globalType = isGeneratorMethod ? globalGeneratorType : globalIteratorType;
|
|
const { mapper } = methodType;
|
|
return createIterationTypes(
|
|
getMappedType(globalType.typeParameters[0], mapper),
|
|
getMappedType(globalType.typeParameters[1], mapper),
|
|
methodName === "next" ? getMappedType(globalType.typeParameters[2], mapper) : void 0
|
|
);
|
|
}
|
|
}
|
|
let methodParameterTypes;
|
|
let methodReturnTypes;
|
|
for (const signature of methodSignatures) {
|
|
if (methodName !== "throw" && some(signature.parameters)) {
|
|
methodParameterTypes = append(methodParameterTypes, getTypeAtPosition(signature, 0));
|
|
}
|
|
methodReturnTypes = append(methodReturnTypes, getReturnTypeOfSignature(signature));
|
|
}
|
|
let returnTypes;
|
|
let nextType;
|
|
if (methodName !== "throw") {
|
|
const methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType;
|
|
if (methodName === "next") {
|
|
nextType = methodParameterType;
|
|
} else if (methodName === "return") {
|
|
const resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
|
|
returnTypes = append(returnTypes, resolvedMethodParameterType);
|
|
}
|
|
}
|
|
let yieldType;
|
|
const methodReturnType = methodReturnTypes ? getIntersectionType(methodReturnTypes) : neverType;
|
|
const resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
|
|
const iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
|
|
if (iterationTypes === noIterationTypes) {
|
|
if (errorNode) {
|
|
if (errorOutputContainer) {
|
|
(_f = errorOutputContainer.errors) != null ? _f : errorOutputContainer.errors = [];
|
|
errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, resolver.mustHaveAValueDiagnostic, methodName));
|
|
} else {
|
|
error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
|
|
}
|
|
}
|
|
yieldType = anyType;
|
|
returnTypes = append(returnTypes, anyType);
|
|
} else {
|
|
yieldType = iterationTypes.yieldType;
|
|
returnTypes = append(returnTypes, iterationTypes.returnType);
|
|
}
|
|
return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
|
|
}
|
|
function getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
const 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);
|
|
}
|
|
function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) {
|
|
if (isTypeAny(returnType)) {
|
|
return void 0;
|
|
}
|
|
const iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator);
|
|
return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)];
|
|
}
|
|
function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
const use = isAsyncGenerator ? 2 /* AsyncGeneratorReturnType */ : 1 /* GeneratorReturnType */;
|
|
const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
|
|
return getIterationTypesOfIterable(type, use, void 0) || getIterationTypesOfIterator(type, resolver, void 0, void 0);
|
|
}
|
|
function checkBreakOrContinueStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node))
|
|
checkGrammarBreakOrContinueStatement(node);
|
|
}
|
|
function unwrapReturnType(returnType, functionFlags) {
|
|
const isGenerator = !!(functionFlags & 1 /* Generator */);
|
|
const isAsync = !!(functionFlags & 2 /* Async */);
|
|
if (isGenerator) {
|
|
const returnIterationType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, isAsync);
|
|
if (!returnIterationType) {
|
|
return errorType;
|
|
}
|
|
return isAsync ? getAwaitedTypeNoAlias(unwrapAwaitedType(returnIterationType)) : returnIterationType;
|
|
}
|
|
return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType;
|
|
}
|
|
function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
|
|
const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(func));
|
|
return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 /* Void */ | 3 /* AnyOrUnknown */);
|
|
}
|
|
function checkReturnStatement(node) {
|
|
var _a2;
|
|
if (checkGrammarStatementInAmbientContext(node)) {
|
|
return;
|
|
}
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block);
|
|
return;
|
|
}
|
|
if (!container) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
|
|
return;
|
|
}
|
|
const signature = getSignatureFromDeclaration(container);
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
const functionFlags = getFunctionFlags(container);
|
|
if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
|
|
const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
|
|
if (container.kind === 175 /* SetAccessor */) {
|
|
if (node.expression) {
|
|
error(node, Diagnostics.Setters_cannot_return_a_value);
|
|
}
|
|
} else if (container.kind === 173 /* Constructor */) {
|
|
if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
|
|
error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
|
|
}
|
|
} else if (getReturnTypeFromAnnotation(container)) {
|
|
const unwrappedReturnType = (_a2 = unwrapReturnType(returnType, functionFlags)) != null ? _a2 : returnType;
|
|
const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(exprType, false, node, 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) {
|
|
checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
|
|
}
|
|
}
|
|
} else if (container.kind !== 173 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) {
|
|
error(node, Diagnostics.Not_all_code_paths_return_a_value);
|
|
}
|
|
}
|
|
function checkWithStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (node.flags & 32768 /* AwaitContext */) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
|
|
}
|
|
}
|
|
checkExpression(node.expression);
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const start = getSpanOfTokenAtPosition(sourceFile, node.pos).start;
|
|
const end = node.statement.pos;
|
|
grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any);
|
|
}
|
|
}
|
|
function checkSwitchStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
let firstDefaultClause;
|
|
let hasDuplicateDefaultClause = false;
|
|
const expressionType = checkExpression(node.expression);
|
|
const expressionIsLiteral = isLiteralType(expressionType);
|
|
forEach(node.caseBlock.clauses, (clause) => {
|
|
if (clause.kind === 293 /* DefaultClause */ && !hasDuplicateDefaultClause) {
|
|
if (firstDefaultClause === void 0) {
|
|
firstDefaultClause = clause;
|
|
} else {
|
|
grammarErrorOnNode(clause, Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
|
|
hasDuplicateDefaultClause = true;
|
|
}
|
|
}
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
addLazyDiagnostic(createLazyCaseClauseDiagnostics(clause));
|
|
}
|
|
forEach(clause.statements, checkSourceElement);
|
|
if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) {
|
|
error(clause, Diagnostics.Fallthrough_case_in_switch);
|
|
}
|
|
function createLazyCaseClauseDiagnostics(clause2) {
|
|
return () => {
|
|
let caseType = checkExpression(clause2.expression);
|
|
const caseIsLiteral = isLiteralType(caseType);
|
|
let comparedExpressionType = expressionType;
|
|
if (!caseIsLiteral || !expressionIsLiteral) {
|
|
caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
|
|
comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
|
|
}
|
|
if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
|
|
checkTypeComparableTo(caseType, comparedExpressionType, clause2.expression, void 0);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
if (node.caseBlock.locals) {
|
|
registerForUnusedIdentifiersCheck(node.caseBlock);
|
|
}
|
|
}
|
|
function checkLabeledStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
findAncestor(node.parent, (current) => {
|
|
if (isFunctionLike(current)) {
|
|
return "quit";
|
|
}
|
|
if (current.kind === 253 /* LabeledStatement */ && current.label.escapedText === node.label.escapedText) {
|
|
grammarErrorOnNode(node.label, Diagnostics.Duplicate_label_0, getTextOfNode(node.label));
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
checkSourceElement(node.statement);
|
|
}
|
|
function checkThrowStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (isIdentifier(node.expression) && !node.expression.escapedText) {
|
|
grammarErrorAfterFirstToken(node, Diagnostics.Line_break_not_permitted_here);
|
|
}
|
|
}
|
|
if (node.expression) {
|
|
checkExpression(node.expression);
|
|
}
|
|
}
|
|
function checkTryStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkBlock(node.tryBlock);
|
|
const catchClause = node.catchClause;
|
|
if (catchClause) {
|
|
if (catchClause.variableDeclaration) {
|
|
const declaration = catchClause.variableDeclaration;
|
|
const typeNode = getEffectiveTypeAnnotationNode(getRootDeclaration(declaration));
|
|
if (typeNode) {
|
|
const type = getTypeForVariableLikeDeclaration(declaration, false, 0 /* Normal */);
|
|
if (type && !(type.flags & 3 /* AnyOrUnknown */)) {
|
|
grammarErrorOnFirstToken(typeNode, Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified);
|
|
}
|
|
} else if (declaration.initializer) {
|
|
grammarErrorOnFirstToken(declaration.initializer, Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
|
|
} else {
|
|
const blockLocals = catchClause.block.locals;
|
|
if (blockLocals) {
|
|
forEachKey(catchClause.locals, (caughtName) => {
|
|
const blockLocal = blockLocals.get(caughtName);
|
|
if ((blockLocal == null ? void 0 : blockLocal.valueDeclaration) && (blockLocal.flags & 2 /* BlockScopedVariable */) !== 0) {
|
|
grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
checkBlock(catchClause.block);
|
|
}
|
|
if (node.finallyBlock) {
|
|
checkBlock(node.finallyBlock);
|
|
}
|
|
}
|
|
function checkIndexConstraints(type, symbol, isStaticIndex) {
|
|
const indexInfos = getIndexInfosOfType(type);
|
|
if (indexInfos.length === 0) {
|
|
return;
|
|
}
|
|
for (const prop of getPropertiesOfObjectType(type)) {
|
|
if (!(isStaticIndex && prop.flags & 4194304 /* Prototype */)) {
|
|
checkIndexConstraintForProperty(type, prop, getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */, true), getNonMissingTypeOfSymbol(prop));
|
|
}
|
|
}
|
|
const typeDeclaration = symbol.valueDeclaration;
|
|
if (typeDeclaration && isClassLike(typeDeclaration)) {
|
|
for (const member of typeDeclaration.members) {
|
|
if (!isStatic(member) && !hasBindableName(member)) {
|
|
const symbol2 = getSymbolOfNode(member);
|
|
checkIndexConstraintForProperty(type, symbol2, getTypeOfExpression(member.name.expression), getNonMissingTypeOfSymbol(symbol2));
|
|
}
|
|
}
|
|
}
|
|
if (indexInfos.length > 1) {
|
|
for (const info of indexInfos) {
|
|
checkIndexConstraintForIndexSignature(type, info);
|
|
}
|
|
}
|
|
}
|
|
function checkIndexConstraintForProperty(type, prop, propNameType, propType) {
|
|
const declaration = prop.valueDeclaration;
|
|
const name = getNameOfDeclaration(declaration);
|
|
if (name && isPrivateIdentifier(name)) {
|
|
return;
|
|
}
|
|
const indexInfos = getApplicableIndexInfos(type, propNameType);
|
|
const interfaceDeclaration = getObjectFlags(type) & 2 /* Interface */ ? getDeclarationOfKind(type.symbol, 261 /* InterfaceDeclaration */) : void 0;
|
|
const propDeclaration = declaration && declaration.kind === 223 /* BinaryExpression */ || name && name.kind === 164 /* ComputedPropertyName */ ? declaration : void 0;
|
|
const localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : void 0;
|
|
for (const info of indexInfos) {
|
|
const localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : void 0;
|
|
const errorNode = localPropDeclaration || localIndexDeclaration || (interfaceDeclaration && !some(getBaseTypes(type), (base) => !!getPropertyOfObjectType(base, prop.escapedName) && !!getIndexTypeOfType(base, info.keyType)) ? interfaceDeclaration : void 0);
|
|
if (errorNode && !isTypeAssignableTo(propType, info.type)) {
|
|
const diagnostic = createError(
|
|
errorNode,
|
|
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) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(propDeclaration, Diagnostics._0_is_declared_here, symbolToString(prop)));
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function checkIndexConstraintForIndexSignature(type, checkInfo) {
|
|
const declaration = checkInfo.declaration;
|
|
const indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
|
|
const interfaceDeclaration = getObjectFlags(type) & 2 /* Interface */ ? getDeclarationOfKind(type.symbol, 261 /* InterfaceDeclaration */) : void 0;
|
|
const localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : void 0;
|
|
for (const info of indexInfos) {
|
|
if (info === checkInfo)
|
|
continue;
|
|
const localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : void 0;
|
|
const errorNode = localCheckDeclaration || localIndexDeclaration || (interfaceDeclaration && !some(getBaseTypes(type), (base) => !!getIndexInfoOfType(base, checkInfo.keyType) && !!getIndexTypeOfType(base, info.keyType)) ? interfaceDeclaration : void 0);
|
|
if (errorNode && !isTypeAssignableTo(checkInfo.type, info.type)) {
|
|
error(
|
|
errorNode,
|
|
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)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function checkTypeNameIsReserved(name, message) {
|
|
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);
|
|
}
|
|
}
|
|
function checkClassNameCollisionWithObject(name) {
|
|
if (languageVersion >= 1 /* ES5 */ && name.escapedText === "Object" && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(name).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
error(name, Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ModuleKind[moduleKind]);
|
|
}
|
|
}
|
|
function checkUnmatchedJSDocParameters(node) {
|
|
const jsdocParameters = filter(getJSDocTags(node), isJSDocParameterTag);
|
|
if (!length(jsdocParameters))
|
|
return;
|
|
const isJs = isInJSFile(node);
|
|
const parameters = /* @__PURE__ */ new Set();
|
|
const excludedParameters = /* @__PURE__ */ new Set();
|
|
forEach(node.parameters, ({ name }, index) => {
|
|
if (isIdentifier(name)) {
|
|
parameters.add(name.escapedText);
|
|
}
|
|
if (isBindingPattern(name)) {
|
|
excludedParameters.add(index);
|
|
}
|
|
});
|
|
const containsArguments = containsArgumentsReference(node);
|
|
if (containsArguments) {
|
|
const lastJSDocParamIndex = jsdocParameters.length - 1;
|
|
const lastJSDocParam = jsdocParameters[lastJSDocParamIndex];
|
|
if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !excludedParameters.has(lastJSDocParamIndex) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
|
|
error(lastJSDocParam.name, 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, idText(lastJSDocParam.name));
|
|
}
|
|
} else {
|
|
forEach(jsdocParameters, ({ name, isNameFirst }, index) => {
|
|
if (excludedParameters.has(index) || isIdentifier(name) && parameters.has(name.escapedText)) {
|
|
return;
|
|
}
|
|
if (isQualifiedName(name)) {
|
|
if (isJs) {
|
|
error(name, Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, entityNameToString(name), entityNameToString(name.left));
|
|
}
|
|
} else {
|
|
if (!isNameFirst) {
|
|
errorOrSuggestion(isJs, name, Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, idText(name));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkTypeParameters(typeParameterDeclarations) {
|
|
let seenDefault = false;
|
|
if (typeParameterDeclarations) {
|
|
for (let i = 0; i < typeParameterDeclarations.length; i++) {
|
|
const node = typeParameterDeclarations[i];
|
|
checkTypeParameter(node);
|
|
addLazyDiagnostic(createCheckTypeParameterDiagnostic(node, i));
|
|
}
|
|
}
|
|
function createCheckTypeParameterDiagnostic(node, i) {
|
|
return () => {
|
|
if (node.default) {
|
|
seenDefault = true;
|
|
checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
|
|
} else if (seenDefault) {
|
|
error(node, Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
|
|
}
|
|
for (let j = 0; j < i; j++) {
|
|
if (typeParameterDeclarations[j].symbol === node.symbol) {
|
|
error(node.name, Diagnostics.Duplicate_identifier_0, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function checkTypeParametersNotReferenced(root, typeParameters, index) {
|
|
visit(root);
|
|
function visit(node) {
|
|
if (node.kind === 180 /* TypeReference */) {
|
|
const type = getTypeFromTypeReference(node);
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
for (let i = index; i < typeParameters.length; i++) {
|
|
if (type.symbol === getSymbolOfNode(typeParameters[i])) {
|
|
error(node, Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
forEachChild(node, visit);
|
|
}
|
|
}
|
|
function checkTypeParameterListsIdentical(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length === 1) {
|
|
return;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.typeParametersChecked) {
|
|
links.typeParametersChecked = true;
|
|
const declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol);
|
|
if (!declarations || declarations.length <= 1) {
|
|
return;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (!areTypeParametersIdentical(declarations, type.localTypeParameters, getEffectiveTypeParameterDeclarations)) {
|
|
const name = symbolToString(symbol);
|
|
for (const declaration of declarations) {
|
|
error(declaration.name, Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function areTypeParametersIdentical(declarations, targetParameters, getTypeParameterDeclarations) {
|
|
const maxTypeArgumentCount = length(targetParameters);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(targetParameters);
|
|
for (const declaration of declarations) {
|
|
const sourceParameters = getTypeParameterDeclarations(declaration);
|
|
const numTypeParameters = sourceParameters.length;
|
|
if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < numTypeParameters; i++) {
|
|
const source = sourceParameters[i];
|
|
const target = targetParameters[i];
|
|
if (source.name.escapedText !== target.symbol.escapedName) {
|
|
return false;
|
|
}
|
|
const constraint = getEffectiveConstraintOfTypeParameter(source);
|
|
const sourceConstraint = constraint && getTypeFromTypeNode(constraint);
|
|
const targetConstraint = getConstraintOfTypeParameter(target);
|
|
if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) {
|
|
return false;
|
|
}
|
|
const sourceDefault = source.default && getTypeFromTypeNode(source.default);
|
|
const 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) {
|
|
forEach(node.members, checkSourceElement);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkClassDeclaration(node) {
|
|
const firstDecorator = find(node.modifiers, isDecorator);
|
|
if (firstDecorator && some(node.members, (p) => hasStaticModifier(p) && isPrivateIdentifierClassElementDeclaration(p))) {
|
|
grammarErrorOnNode(firstDecorator, Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator);
|
|
}
|
|
if (!node.name && !hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
|
|
}
|
|
checkClassLikeDeclaration(node);
|
|
forEach(node.members, checkSourceElement);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkClassLikeDeclaration(node) {
|
|
checkGrammarClassLikeDeclaration(node);
|
|
checkDecorators(node);
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
checkTypeParameterListsIdentical(symbol);
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
checkClassForDuplicateDeclarations(node);
|
|
const nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
|
|
if (!nodeInAmbientContext) {
|
|
checkClassForStaticPropertyNameConflicts(node);
|
|
}
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
if (baseTypeNode) {
|
|
forEach(baseTypeNode.typeArguments, checkSourceElement);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(baseTypeNode.parent, 1 /* Extends */);
|
|
}
|
|
const extendsNode = getClassExtendsHeritageElement(node);
|
|
if (extendsNode && extendsNode !== baseTypeNode) {
|
|
checkExpression(extendsNode.expression);
|
|
}
|
|
const baseTypes = getBaseTypes(type);
|
|
if (baseTypes.length) {
|
|
addLazyDiagnostic(() => {
|
|
const baseType = baseTypes[0];
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(type);
|
|
const staticBaseType = getApparentType(baseConstructorType);
|
|
checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
|
|
checkSourceElement(baseTypeNode.expression);
|
|
if (some(baseTypeNode.typeArguments)) {
|
|
forEach(baseTypeNode.typeArguments, checkSourceElement);
|
|
for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode)) {
|
|
if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const baseWithThis = getTypeWithThisArgument(baseType, type.thisType);
|
|
if (!checkTypeAssignableTo(typeWithThis, baseWithThis, void 0)) {
|
|
issueMemberSpecificError(node, typeWithThis, baseWithThis, Diagnostics.Class_0_incorrectly_extends_base_class_1);
|
|
} else {
|
|
checkTypeAssignableTo(
|
|
staticType,
|
|
getTypeWithoutSignatures(staticBaseType),
|
|
node.name || node,
|
|
Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1
|
|
);
|
|
}
|
|
if (baseConstructorType.flags & 8650752 /* TypeVariable */) {
|
|
if (!isMixinConstructorType(staticType)) {
|
|
error(node.name || node, Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
|
|
} else {
|
|
const constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
|
|
if (constructSignatures.some((signature) => signature.flags & 4 /* Abstract */) && !hasSyntacticModifier(node, 256 /* Abstract */)) {
|
|
error(node.name || node, 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 /* Class */) && !(baseConstructorType.flags & 8650752 /* TypeVariable */)) {
|
|
const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
|
|
if (forEach(constructors, (sig) => !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType))) {
|
|
error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type);
|
|
}
|
|
}
|
|
checkKindsOfPropertyMemberOverrides(type, baseType);
|
|
});
|
|
}
|
|
}
|
|
checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
|
|
const implementedTypeNodes = getEffectiveImplementsTypeNodes(node);
|
|
if (implementedTypeNodes) {
|
|
for (const typeRefNode of implementedTypeNodes) {
|
|
if (!isEntityNameExpression(typeRefNode.expression) || isOptionalChain(typeRefNode.expression)) {
|
|
error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
|
}
|
|
checkTypeReferenceNode(typeRefNode);
|
|
addLazyDiagnostic(createImplementsDiagnostics(typeRefNode));
|
|
}
|
|
}
|
|
addLazyDiagnostic(() => {
|
|
checkIndexConstraints(type, symbol);
|
|
checkIndexConstraints(staticType, symbol, true);
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
checkPropertyInitialization(node);
|
|
});
|
|
function createImplementsDiagnostics(typeRefNode) {
|
|
return () => {
|
|
const t = getReducedType(getTypeFromTypeNode(typeRefNode));
|
|
if (!isErrorType(t)) {
|
|
if (isValidBaseType(t)) {
|
|
const genericDiag = t.symbol && t.symbol.flags & 32 /* Class */ ? Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass : Diagnostics.Class_0_incorrectly_implements_interface_1;
|
|
const baseWithThis = getTypeWithThisArgument(t, type.thisType);
|
|
if (!checkTypeAssignableTo(typeWithThis, baseWithThis, void 0)) {
|
|
issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
|
|
}
|
|
} else {
|
|
error(typeRefNode, Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
const baseTypes = baseTypeNode && getBaseTypes(type);
|
|
const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
|
|
const baseStaticType = getBaseConstructorTypeOfClass(type);
|
|
for (const member of node.members) {
|
|
if (hasAmbientModifier(member)) {
|
|
continue;
|
|
}
|
|
if (isConstructorDeclaration(member)) {
|
|
forEach(member.parameters, (param) => {
|
|
if (isParameterPropertyDeclaration(param, member)) {
|
|
checkExistingMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
param,
|
|
true
|
|
);
|
|
}
|
|
});
|
|
}
|
|
checkExistingMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
member,
|
|
false
|
|
);
|
|
}
|
|
}
|
|
function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors2 = true) {
|
|
const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
|
|
if (!declaredProp) {
|
|
return 0 /* Ok */;
|
|
}
|
|
return checkMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
hasOverrideModifier(member),
|
|
hasAbstractModifier(member),
|
|
isStatic(member),
|
|
memberIsParameterProperty,
|
|
symbolName(declaredProp),
|
|
reportErrors2 ? member : void 0
|
|
);
|
|
}
|
|
function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
|
|
const isJs = isInJSFile(node);
|
|
const nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
|
|
if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
|
|
const memberEscapedName = escapeLeadingUnderscores(memberName);
|
|
const thisType = memberIsStatic ? staticType : typeWithThis;
|
|
const baseType = memberIsStatic ? baseStaticType : baseWithThis;
|
|
const prop = getPropertyOfType(thisType, memberEscapedName);
|
|
const baseProp = getPropertyOfType(baseType, memberEscapedName);
|
|
const baseClassName = typeToString(baseWithThis);
|
|
if (prop && !baseProp && memberHasOverrideModifier) {
|
|
if (errorNode) {
|
|
const suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType);
|
|
suggestion ? error(
|
|
errorNode,
|
|
isJs ? 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 : 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 ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 : Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0,
|
|
baseClassName
|
|
);
|
|
}
|
|
return 2 /* HasInvalidOverride */;
|
|
} else if (prop && (baseProp == null ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
|
|
const baseHasAbstract = some(baseProp.declarations, hasAbstractModifier);
|
|
if (memberHasOverrideModifier) {
|
|
return 0 /* Ok */;
|
|
}
|
|
if (!baseHasAbstract) {
|
|
if (errorNode) {
|
|
const diag2 = memberIsParameterProperty ? isJs ? Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 : isJs ? Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0;
|
|
error(errorNode, diag2, baseClassName);
|
|
}
|
|
return 1 /* NeedsOverride */;
|
|
} else if (memberHasAbstractModifier && baseHasAbstract) {
|
|
if (errorNode) {
|
|
error(errorNode, 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 /* NeedsOverride */;
|
|
}
|
|
}
|
|
} else if (memberHasOverrideModifier) {
|
|
if (errorNode) {
|
|
const className = typeToString(type);
|
|
error(
|
|
errorNode,
|
|
isJs ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class : Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class,
|
|
className
|
|
);
|
|
}
|
|
return 2 /* HasInvalidOverride */;
|
|
}
|
|
return 0 /* Ok */;
|
|
}
|
|
function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
|
|
let issuedMemberError = false;
|
|
for (const member of node.members) {
|
|
if (isStatic(member)) {
|
|
continue;
|
|
}
|
|
const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
|
|
if (declaredProp) {
|
|
const prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
|
|
const baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
|
|
if (prop && baseProp) {
|
|
const rootChain = () => chainDiagnosticMessages(
|
|
void 0,
|
|
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, void 0, rootChain)) {
|
|
issuedMemberError = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!issuedMemberError) {
|
|
checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag);
|
|
}
|
|
}
|
|
function checkBaseTypeAccessibility(type, node) {
|
|
const signatures = getSignaturesOfType(type, 1 /* Construct */);
|
|
if (signatures.length) {
|
|
const declaration = signatures[0].declaration;
|
|
if (declaration && hasEffectiveModifier(declaration, 8 /* Private */)) {
|
|
const typeClassDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (!isNodeWithinClass(node, typeClassDeclaration)) {
|
|
error(node, Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getMemberOverrideModifierStatus(node, member) {
|
|
if (!member.name) {
|
|
return 0 /* Ok */;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
const baseTypes = baseTypeNode && getBaseTypes(type);
|
|
const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
|
|
const baseStaticType = getBaseConstructorTypeOfClass(type);
|
|
const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
|
|
const memberName = unescapeLeadingUnderscores(getTextOfPropertyName(member.name));
|
|
return checkMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
memberHasOverrideModifier,
|
|
hasAbstractModifier(member),
|
|
isStatic(member),
|
|
false,
|
|
memberName
|
|
);
|
|
}
|
|
function getTargetSymbol(s) {
|
|
return getCheckFlags(s) & 1 /* Instantiated */ ? s.target : s;
|
|
}
|
|
function getClassOrInterfaceDeclarationsOfSymbol(symbol) {
|
|
return filter(symbol.declarations, (d) => d.kind === 260 /* ClassDeclaration */ || d.kind === 261 /* InterfaceDeclaration */);
|
|
}
|
|
function checkKindsOfPropertyMemberOverrides(type, baseType) {
|
|
var _a2, _b, _c, _d;
|
|
const baseProperties = getPropertiesOfType(baseType);
|
|
basePropertyCheck:
|
|
for (const baseProperty of baseProperties) {
|
|
const base = getTargetSymbol(baseProperty);
|
|
if (base.flags & 4194304 /* Prototype */) {
|
|
continue;
|
|
}
|
|
const baseSymbol = getPropertyOfObjectType(type, base.escapedName);
|
|
if (!baseSymbol) {
|
|
continue;
|
|
}
|
|
const derived = getTargetSymbol(baseSymbol);
|
|
const baseDeclarationFlags = getDeclarationModifierFlagsFromSymbol(base);
|
|
Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
|
|
if (derived === base) {
|
|
const derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 256 /* Abstract */))) {
|
|
for (const otherBaseType of getBaseTypes(type)) {
|
|
if (otherBaseType === baseType)
|
|
continue;
|
|
const baseSymbol2 = getPropertyOfObjectType(otherBaseType, base.escapedName);
|
|
const derivedElsewhere = baseSymbol2 && getTargetSymbol(baseSymbol2);
|
|
if (derivedElsewhere && derivedElsewhere !== base) {
|
|
continue basePropertyCheck;
|
|
}
|
|
}
|
|
if (derivedClassDecl.kind === 228 /* ClassExpression */) {
|
|
error(
|
|
derivedClassDecl,
|
|
Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1,
|
|
symbolToString(baseProperty),
|
|
typeToString(baseType)
|
|
);
|
|
} else {
|
|
error(
|
|
derivedClassDecl,
|
|
Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2,
|
|
typeToString(type),
|
|
symbolToString(baseProperty),
|
|
typeToString(baseType)
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
|
|
if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
|
|
continue;
|
|
}
|
|
let errorMessage;
|
|
const basePropertyFlags = base.flags & 98308 /* PropertyOrAccessor */;
|
|
const derivedPropertyFlags = derived.flags & 98308 /* PropertyOrAccessor */;
|
|
if (basePropertyFlags && derivedPropertyFlags) {
|
|
if ((getCheckFlags(base) & 6 /* Synthetic */ ? (_a2 = base.declarations) == null ? void 0 : _a2.some((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags)) : (_b = base.declarations) == null ? void 0 : _b.every((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags))) || getCheckFlags(base) & 262144 /* Mapped */ || derived.valueDeclaration && isBinaryExpression(derived.valueDeclaration)) {
|
|
continue;
|
|
}
|
|
const overriddenInstanceProperty = basePropertyFlags !== 4 /* Property */ && derivedPropertyFlags === 4 /* Property */;
|
|
const overriddenInstanceAccessor = basePropertyFlags === 4 /* Property */ && derivedPropertyFlags !== 4 /* Property */;
|
|
if (overriddenInstanceProperty || overriddenInstanceAccessor) {
|
|
const errorMessage2 = overriddenInstanceProperty ? Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
|
|
error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType), typeToString(type));
|
|
} else if (useDefineForClassFields) {
|
|
const uninitialized = (_c = derived.declarations) == null ? void 0 : _c.find((d) => d.kind === 169 /* PropertyDeclaration */ && !d.initializer);
|
|
if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 256 /* Abstract */) && !(derivedDeclarationFlags & 256 /* Abstract */) && !((_d = derived.declarations) == null ? void 0 : _d.some((d) => !!(d.flags & 16777216 /* Ambient */)))) {
|
|
const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(type.symbol));
|
|
const propName = uninitialized.name;
|
|
if (uninitialized.exclamationToken || !constructor || !isIdentifier(propName) || !strictNullChecks || !isPropertyInitializedInConstructor(propName, type, constructor)) {
|
|
const errorMessage2 = 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(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType));
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
} else if (isPrototypeProperty(base)) {
|
|
if (isPrototypeProperty(derived) || derived.flags & 4 /* Property */) {
|
|
continue;
|
|
} else {
|
|
Debug.assert(!!(derived.flags & 98304 /* Accessor */));
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
|
|
}
|
|
} else if (base.flags & 98304 /* Accessor */) {
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
|
|
} else {
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
|
|
}
|
|
error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
|
|
}
|
|
}
|
|
}
|
|
function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
|
|
return baseDeclarationFlags & 256 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
|
|
}
|
|
function getNonInheritedProperties(type, baseTypes, properties) {
|
|
if (!length(baseTypes)) {
|
|
return properties;
|
|
}
|
|
const seen = /* @__PURE__ */ new Map();
|
|
forEach(properties, (p) => {
|
|
seen.set(p.escapedName, p);
|
|
});
|
|
for (const base of baseTypes) {
|
|
const properties2 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
|
|
for (const prop of properties2) {
|
|
const existing = seen.get(prop.escapedName);
|
|
if (existing && prop.parent === existing.parent) {
|
|
seen.delete(prop.escapedName);
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(seen.values());
|
|
}
|
|
function checkInheritedPropertiesAreIdentical(type, typeNode) {
|
|
const baseTypes = getBaseTypes(type);
|
|
if (baseTypes.length < 2) {
|
|
return true;
|
|
}
|
|
const seen = /* @__PURE__ */ new Map();
|
|
forEach(resolveDeclaredMembers(type).declaredProperties, (p) => {
|
|
seen.set(p.escapedName, { prop: p, containingType: type });
|
|
});
|
|
let ok = true;
|
|
for (const base of baseTypes) {
|
|
const properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
|
|
for (const prop of properties) {
|
|
const existing = seen.get(prop.escapedName);
|
|
if (!existing) {
|
|
seen.set(prop.escapedName, { prop, containingType: base });
|
|
} else {
|
|
const isInheritedProperty = existing.containingType !== type;
|
|
if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
|
|
ok = false;
|
|
const typeName1 = typeToString(existing.containingType);
|
|
const typeName2 = typeToString(base);
|
|
let errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(typeNode, errorInfo));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
function checkPropertyInitialization(node) {
|
|
if (!strictNullChecks || !strictPropertyInitialization || node.flags & 16777216 /* Ambient */) {
|
|
return;
|
|
}
|
|
const constructor = findConstructorDeclaration(node);
|
|
for (const member of node.members) {
|
|
if (getEffectiveModifierFlags(member) & 2 /* Ambient */) {
|
|
continue;
|
|
}
|
|
if (!isStatic(member) && isPropertyWithoutInitializer(member)) {
|
|
const propName = member.name;
|
|
if (isIdentifier(propName) || isPrivateIdentifier(propName) || isComputedPropertyName(propName)) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(member));
|
|
if (!(type.flags & 3 /* AnyOrUnknown */ || containsUndefinedType(type))) {
|
|
if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
|
|
error(member.name, Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, declarationNameToString(propName));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isPropertyWithoutInitializer(node) {
|
|
return node.kind === 169 /* PropertyDeclaration */ && !hasAbstractModifier(node) && !node.exclamationToken && !node.initializer;
|
|
}
|
|
function isPropertyInitializedInStaticBlocks(propName, propType, staticBlocks, startPos, endPos) {
|
|
for (const staticBlock of staticBlocks) {
|
|
if (staticBlock.pos >= startPos && staticBlock.pos <= endPos) {
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), propName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, staticBlock);
|
|
reference.flowNode = staticBlock.returnFlowNode;
|
|
const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
|
|
if (!containsUndefinedType(flowType)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isPropertyInitializedInConstructor(propName, propType, constructor) {
|
|
const reference = isComputedPropertyName(propName) ? factory.createElementAccessExpression(factory.createThis(), propName.expression) : factory.createPropertyAccessExpression(factory.createThis(), propName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, constructor);
|
|
reference.flowNode = constructor.returnFlowNode;
|
|
const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
|
|
return !containsUndefinedType(flowType);
|
|
}
|
|
function checkInterfaceDeclaration(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node))
|
|
checkGrammarInterfaceDeclaration(node);
|
|
checkTypeParameters(node.typeParameters);
|
|
addLazyDiagnostic(() => {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
checkTypeParameterListsIdentical(symbol);
|
|
const firstInterfaceDecl = getDeclarationOfKind(symbol, 261 /* InterfaceDeclaration */);
|
|
if (node === firstInterfaceDecl) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
if (checkInheritedPropertiesAreIdentical(type, node.name)) {
|
|
for (const baseType of getBaseTypes(type)) {
|
|
checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1);
|
|
}
|
|
checkIndexConstraints(type, symbol);
|
|
}
|
|
}
|
|
checkObjectTypeForDuplicateDeclarations(node);
|
|
});
|
|
forEach(getInterfaceBaseTypeNodes(node), (heritageElement) => {
|
|
if (!isEntityNameExpression(heritageElement.expression) || isOptionalChain(heritageElement.expression)) {
|
|
error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
|
}
|
|
checkTypeReferenceNode(heritageElement);
|
|
});
|
|
forEach(node.members, checkSourceElement);
|
|
addLazyDiagnostic(() => {
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
});
|
|
}
|
|
function checkTypeAliasDeclaration(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
|
|
checkExportsOnMergedDeclarations(node);
|
|
checkTypeParameters(node.typeParameters);
|
|
if (node.type.kind === 139 /* IntrinsicKeyword */) {
|
|
if (!intrinsicTypeKinds.has(node.name.escapedText) || length(node.typeParameters) !== 1) {
|
|
error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types);
|
|
}
|
|
} else {
|
|
checkSourceElement(node.type);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function computeEnumMemberValues(node) {
|
|
const nodeLinks2 = getNodeLinks(node);
|
|
if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
|
|
nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
|
|
let autoValue = 0;
|
|
for (const member of node.members) {
|
|
const value = computeMemberValue(member, autoValue);
|
|
getNodeLinks(member).enumMemberValue = value;
|
|
autoValue = typeof value === "number" ? value + 1 : void 0;
|
|
}
|
|
}
|
|
}
|
|
function computeMemberValue(member, autoValue) {
|
|
if (isComputedNonLiteralName(member.name)) {
|
|
error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
|
|
} else {
|
|
const text = getTextOfPropertyName(member.name);
|
|
if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
|
|
error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
|
|
}
|
|
}
|
|
if (member.initializer) {
|
|
return computeConstantValue(member);
|
|
}
|
|
if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent)) {
|
|
return void 0;
|
|
}
|
|
if (autoValue !== void 0) {
|
|
return autoValue;
|
|
}
|
|
error(member.name, Diagnostics.Enum_member_must_have_initializer);
|
|
return void 0;
|
|
}
|
|
function computeConstantValue(member) {
|
|
const isConstEnum = isEnumConst(member.parent);
|
|
const initializer = member.initializer;
|
|
const value = evaluate(initializer, member);
|
|
if (value !== void 0) {
|
|
if (isConstEnum && typeof value === "number" && !isFinite(value)) {
|
|
error(initializer, isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
|
|
}
|
|
} else if (isConstEnum) {
|
|
error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
|
|
} else if (member.parent.flags & 16777216 /* Ambient */) {
|
|
error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
|
|
} else {
|
|
checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
|
|
}
|
|
return value;
|
|
}
|
|
function evaluate(expr, location) {
|
|
switch (expr.kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const value = evaluate(expr.operand, location);
|
|
if (typeof value === "number") {
|
|
switch (expr.operator) {
|
|
case 39 /* PlusToken */:
|
|
return value;
|
|
case 40 /* MinusToken */:
|
|
return -value;
|
|
case 54 /* TildeToken */:
|
|
return ~value;
|
|
}
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
const left = evaluate(expr.left, location);
|
|
const right = evaluate(expr.right, location);
|
|
if (typeof left === "number" && typeof right === "number") {
|
|
switch (expr.operatorToken.kind) {
|
|
case 51 /* BarToken */:
|
|
return left | right;
|
|
case 50 /* AmpersandToken */:
|
|
return left & right;
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
return left >> right;
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
return left >>> right;
|
|
case 47 /* LessThanLessThanToken */:
|
|
return left << right;
|
|
case 52 /* CaretToken */:
|
|
return left ^ right;
|
|
case 41 /* AsteriskToken */:
|
|
return left * right;
|
|
case 43 /* SlashToken */:
|
|
return left / right;
|
|
case 39 /* PlusToken */:
|
|
return left + right;
|
|
case 40 /* MinusToken */:
|
|
return left - right;
|
|
case 44 /* PercentToken */:
|
|
return left % right;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return left ** right;
|
|
}
|
|
} else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 39 /* PlusToken */) {
|
|
return "" + left + right;
|
|
}
|
|
break;
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return expr.text;
|
|
case 225 /* TemplateExpression */:
|
|
return evaluateTemplateExpression(expr, location);
|
|
case 8 /* NumericLiteral */:
|
|
checkGrammarNumericLiteral(expr);
|
|
return +expr.text;
|
|
case 214 /* ParenthesizedExpression */:
|
|
return evaluate(expr.expression, location);
|
|
case 79 /* Identifier */:
|
|
if (isInfinityOrNaNString(expr.escapedText)) {
|
|
return +expr.escapedText;
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (isEntityNameExpression(expr)) {
|
|
const symbol = resolveEntityName(expr, 111551 /* Value */, true);
|
|
if (symbol) {
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return evaluateEnumMember(expr, symbol, location);
|
|
}
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
|
|
return evaluate(declaration.initializer, declaration);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
const root = expr.expression;
|
|
if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
|
|
const rootSymbol = resolveEntityName(root, 111551 /* Value */, true);
|
|
if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
|
|
const name = escapeLeadingUnderscores(expr.argumentExpression.text);
|
|
const member = rootSymbol.exports.get(name);
|
|
if (member) {
|
|
return evaluateEnumMember(expr, member, location);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return void 0;
|
|
}
|
|
function evaluateEnumMember(expr, symbol, location) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (!declaration || declaration === location) {
|
|
error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
|
|
return void 0;
|
|
}
|
|
if (!isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
|
|
error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
|
|
return 0;
|
|
}
|
|
return getEnumMemberValue(declaration);
|
|
}
|
|
function evaluateTemplateExpression(expr, location) {
|
|
let result = expr.head.text;
|
|
for (const span of expr.templateSpans) {
|
|
const value = evaluate(span.expression, location);
|
|
if (value === void 0) {
|
|
return void 0;
|
|
}
|
|
result += value;
|
|
result += span.literal.text;
|
|
}
|
|
return result;
|
|
}
|
|
function checkEnumDeclaration(node) {
|
|
addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
|
|
}
|
|
function checkEnumDeclarationWorker(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
checkExportsOnMergedDeclarations(node);
|
|
node.members.forEach(checkEnumMember);
|
|
computeEnumMemberValues(node);
|
|
const enumSymbol = getSymbolOfNode(node);
|
|
const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
|
|
if (node === firstDeclaration) {
|
|
if (enumSymbol.declarations && enumSymbol.declarations.length > 1) {
|
|
const enumIsConst = isEnumConst(node);
|
|
forEach(enumSymbol.declarations, (decl) => {
|
|
if (isEnumDeclaration(decl) && isEnumConst(decl) !== enumIsConst) {
|
|
error(getNameOfDeclaration(decl), Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
|
|
}
|
|
});
|
|
}
|
|
let seenEnumMissingInitialInitializer = false;
|
|
forEach(enumSymbol.declarations, (declaration) => {
|
|
if (declaration.kind !== 263 /* EnumDeclaration */) {
|
|
return false;
|
|
}
|
|
const enumDeclaration = declaration;
|
|
if (!enumDeclaration.members.length) {
|
|
return false;
|
|
}
|
|
const firstEnumMember = enumDeclaration.members[0];
|
|
if (!firstEnumMember.initializer) {
|
|
if (seenEnumMissingInitialInitializer) {
|
|
error(firstEnumMember.name, Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
|
|
} else {
|
|
seenEnumMissingInitialInitializer = true;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkEnumMember(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
error(node, Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
|
|
}
|
|
if (node.initializer) {
|
|
checkExpression(node.initializer);
|
|
}
|
|
}
|
|
function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
|
|
const declarations = symbol.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
if ((declaration.kind === 260 /* ClassDeclaration */ || declaration.kind === 259 /* FunctionDeclaration */ && nodeIsPresent(declaration.body)) && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function inSameLexicalScope(node1, node2) {
|
|
const container1 = getEnclosingBlockScopeContainer(node1);
|
|
const container2 = 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 (!isGlobalScopeAugmentation(node)) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
addLazyDiagnostic(checkModuleDeclarationDiagnostics);
|
|
function checkModuleDeclarationDiagnostics() {
|
|
const isGlobalAugmentation = isGlobalScopeAugmentation(node);
|
|
const inAmbientContext = node.flags & 16777216 /* Ambient */;
|
|
if (isGlobalAugmentation && !inAmbientContext) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
|
|
}
|
|
const isAmbientExternalModule = isAmbientModule(node);
|
|
const contextErrorMessage = isAmbientExternalModule ? Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file : Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module;
|
|
if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node)) {
|
|
if (!inAmbientContext && node.name.kind === 10 /* StringLiteral */) {
|
|
grammarErrorOnNode(node.name, Diagnostics.Only_ambient_modules_can_use_quoted_names);
|
|
}
|
|
}
|
|
if (isIdentifier(node.name)) {
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 512 /* ValueModule */ && !inAmbientContext && symbol.declarations && symbol.declarations.length > 1 && isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions))) {
|
|
const firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
|
|
if (firstNonAmbientClassOrFunc) {
|
|
if (getSourceFileOfNode(node) !== getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
|
|
error(node.name, 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, Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
|
|
}
|
|
}
|
|
const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
|
|
if (mergedClass && inSameLexicalScope(node, mergedClass)) {
|
|
getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
|
|
}
|
|
}
|
|
if (isAmbientExternalModule) {
|
|
if (isExternalModuleAugmentation(node)) {
|
|
const checkBody = isGlobalAugmentation || getSymbolOfNode(node).flags & 33554432 /* Transient */;
|
|
if (checkBody && node.body) {
|
|
for (const statement of node.body.statements) {
|
|
checkModuleAugmentationElement(statement, isGlobalAugmentation);
|
|
}
|
|
}
|
|
} else if (isGlobalSourceFile(node.parent)) {
|
|
if (isGlobalAugmentation) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
|
|
} else if (isExternalModuleNameRelative(getTextOfIdentifierOrLiteral(node.name))) {
|
|
error(node.name, Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name);
|
|
}
|
|
} else {
|
|
if (isGlobalAugmentation) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
|
|
} else {
|
|
error(node.name, Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkModuleAugmentationElement(node, isGlobalAugmentation) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
for (const decl of node.declarationList.declarations) {
|
|
checkModuleAugmentationElement(decl, isGlobalAugmentation);
|
|
}
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
case 275 /* ExportDeclaration */:
|
|
grammarErrorOnFirstToken(node, Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations);
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
grammarErrorOnFirstToken(node, Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
case 257 /* VariableDeclaration */:
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
for (const el of name.elements) {
|
|
checkModuleAugmentationElement(el, isGlobalAugmentation);
|
|
}
|
|
break;
|
|
}
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
if (isGlobalAugmentation) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function getFirstNonModuleExportsIdentifier(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.left;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
do {
|
|
if (isModuleExportsAccessExpression(node.expression) && !isPrivateIdentifier(node.name)) {
|
|
return node.name;
|
|
}
|
|
node = node.expression;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
}
|
|
}
|
|
function checkExternalImportOrExportDeclaration(node) {
|
|
const moduleName = getExternalModuleName(node);
|
|
if (!moduleName || nodeIsMissing(moduleName)) {
|
|
return false;
|
|
}
|
|
if (!isStringLiteral(moduleName)) {
|
|
error(moduleName, Diagnostics.String_literal_expected);
|
|
return false;
|
|
}
|
|
const inAmbientExternalModule = node.parent.kind === 265 /* ModuleBlock */ && isAmbientModule(node.parent.parent);
|
|
if (node.parent.kind !== 308 /* SourceFile */ && !inAmbientExternalModule) {
|
|
error(moduleName, node.kind === 275 /* ExportDeclaration */ ? Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module);
|
|
return false;
|
|
}
|
|
if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) {
|
|
if (!isTopLevelInExternalModuleAugmentation(node)) {
|
|
error(node, Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name);
|
|
return false;
|
|
}
|
|
}
|
|
if (!isImportEqualsDeclaration(node) && node.assertClause) {
|
|
let hasError = false;
|
|
for (const clause of node.assertClause.elements) {
|
|
if (!isStringLiteral(clause.value)) {
|
|
hasError = true;
|
|
error(clause.value, Diagnostics.Import_assertion_values_must_be_string_literal_expressions);
|
|
}
|
|
}
|
|
return !hasError;
|
|
}
|
|
return true;
|
|
}
|
|
function checkAliasSymbol(node) {
|
|
var _a2, _b, _c, _d, _e;
|
|
let symbol = getSymbolOfNode(node);
|
|
const target = resolveAlias(symbol);
|
|
if (target !== unknownSymbol) {
|
|
symbol = getMergedSymbol(symbol.exportSymbol || symbol);
|
|
if (isInJSFile(node) && !(target.flags & 111551 /* Value */) && !isTypeOnlyImportOrExportDeclaration(node)) {
|
|
const errorNode = isImportOrExportSpecifier(node) ? node.propertyName || node.name : isNamedDeclaration(node) ? node.name : node;
|
|
Debug.assert(node.kind !== 277 /* NamespaceExport */);
|
|
if (node.kind === 278 /* ExportSpecifier */) {
|
|
const diag2 = error(errorNode, Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files);
|
|
const alreadyExportedSymbol = (_b = (_a2 = getSourceFileOfNode(node).symbol) == null ? void 0 : _a2.exports) == null ? void 0 : _b.get((node.propertyName || node.name).escapedText);
|
|
if (alreadyExportedSymbol === target) {
|
|
const exportingDeclaration = (_c = alreadyExportedSymbol.declarations) == null ? void 0 : _c.find(isJSDocNode);
|
|
if (exportingDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(
|
|
exportingDeclaration,
|
|
Diagnostics._0_is_automatically_exported_here,
|
|
unescapeLeadingUnderscores(alreadyExportedSymbol.escapedName)
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
Debug.assert(node.kind !== 257 /* VariableDeclaration */);
|
|
const importDeclaration = findAncestor(node, or(isImportDeclaration, isImportEqualsDeclaration));
|
|
const moduleSpecifier = (_e = importDeclaration && ((_d = tryGetModuleSpecifierFromDeclaration(importDeclaration)) == null ? void 0 : _d.text)) != null ? _e : "...";
|
|
const importedIdentifier = unescapeLeadingUnderscores(isIdentifier(errorNode) ? errorNode.escapedText : symbol.escapedName);
|
|
error(
|
|
errorNode,
|
|
Diagnostics._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation,
|
|
importedIdentifier,
|
|
`import("${moduleSpecifier}").${importedIdentifier}`
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
const targetFlags = getAllSymbolFlags(target);
|
|
const excludedMeanings = (symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */) ? 111551 /* Value */ : 0) | (symbol.flags & 788968 /* Type */ ? 788968 /* Type */ : 0) | (symbol.flags & 1920 /* Namespace */ ? 1920 /* Namespace */ : 0);
|
|
if (targetFlags & excludedMeanings) {
|
|
const message = node.kind === 278 /* ExportSpecifier */ ? Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
|
|
error(node, message, symbolToString(symbol));
|
|
}
|
|
if (compilerOptions.isolatedModules && !isTypeOnlyImportOrExportDeclaration(node) && !(node.flags & 16777216 /* Ambient */)) {
|
|
const typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
|
|
const isType = !(targetFlags & 111551 /* Value */);
|
|
if (isType || typeOnlyAlias) {
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 268 /* ImportEqualsDeclaration */: {
|
|
if (compilerOptions.preserveValueImports) {
|
|
Debug.assertIsDefined(node.name, "An ImportClause with a symbol should have a name");
|
|
const message = isType ? Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled;
|
|
const name = idText(node.kind === 273 /* ImportSpecifier */ ? node.propertyName || node.name : node.name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(node, message, name),
|
|
isType ? void 0 : typeOnlyAlias,
|
|
name
|
|
);
|
|
}
|
|
if (isType && node.kind === 268 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 1 /* Export */)) {
|
|
error(node, Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided);
|
|
}
|
|
break;
|
|
}
|
|
case 278 /* ExportSpecifier */: {
|
|
if (getSourceFileOfNode(typeOnlyAlias) !== getSourceFileOfNode(node)) {
|
|
const message = isType ? Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled;
|
|
const name = idText(node.propertyName || node.name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(node, message, name),
|
|
isType ? void 0 : typeOnlyAlias,
|
|
name
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isImportSpecifier(node)) {
|
|
const targetSymbol = checkDeprecatedAliasedSymbol(symbol, node);
|
|
if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) {
|
|
addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isDeprecatedAliasedSymbol(symbol) {
|
|
return !!symbol.declarations && every(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
|
|
}
|
|
function checkDeprecatedAliasedSymbol(symbol, location) {
|
|
if (!(symbol.flags & 2097152 /* Alias */))
|
|
return symbol;
|
|
const targetSymbol = resolveAlias(symbol);
|
|
if (targetSymbol === unknownSymbol)
|
|
return targetSymbol;
|
|
while (symbol.flags & 2097152 /* Alias */) {
|
|
const target = getImmediateAliasedSymbol(symbol);
|
|
if (target) {
|
|
if (target === targetSymbol)
|
|
break;
|
|
if (target.declarations && 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 /* ImportSpecifier */ && idText(node.propertyName || node.name) === "default" && getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
|
|
}
|
|
}
|
|
function checkAssertClause(declaration) {
|
|
var _a2;
|
|
if (declaration.assertClause) {
|
|
const validForTypeAssertions = isExclusivelyTypeOnlyImportOrExport(declaration);
|
|
const override = getResolutionModeOverrideForClause(declaration.assertClause, validForTypeAssertions ? grammarErrorOnNode : void 0);
|
|
if (validForTypeAssertions && override) {
|
|
if (!isNightly()) {
|
|
grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
|
|
}
|
|
return;
|
|
}
|
|
const mode = moduleKind === 199 /* NodeNext */ && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
|
|
if (mode !== 99 /* ESNext */ && moduleKind !== 99 /* ESNext */) {
|
|
return grammarErrorOnNode(
|
|
declaration.assertClause,
|
|
moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext
|
|
);
|
|
}
|
|
if (isImportDeclaration(declaration) ? (_a2 = declaration.importClause) == null ? void 0 : _a2.isTypeOnly : declaration.isTypeOnly) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
|
|
}
|
|
if (override) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_can_only_be_set_for_type_only_imports);
|
|
}
|
|
}
|
|
}
|
|
function checkImportDeclaration(node) {
|
|
if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
|
|
}
|
|
if (checkExternalImportOrExportDeclaration(node)) {
|
|
const importClause = node.importClause;
|
|
if (importClause && !checkGrammarImportClause(importClause)) {
|
|
if (importClause.name) {
|
|
checkImportBinding(importClause);
|
|
}
|
|
if (importClause.namedBindings) {
|
|
if (importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
checkImportBinding(importClause.namedBindings);
|
|
if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && getESModuleInterop(compilerOptions)) {
|
|
checkExternalEmitHelpers(node, 65536 /* ImportStar */);
|
|
}
|
|
} else {
|
|
const moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (moduleExisted) {
|
|
forEach(importClause.namedBindings.elements, checkImportBinding);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkAssertClause(node);
|
|
}
|
|
function checkImportEqualsDeclaration(node) {
|
|
if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
|
|
checkImportBinding(node);
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
markExportAsReferenced(node);
|
|
}
|
|
if (node.moduleReference.kind !== 280 /* ExternalModuleReference */) {
|
|
const target = resolveAlias(getSymbolOfNode(node));
|
|
if (target !== unknownSymbol) {
|
|
const targetFlags = getAllSymbolFlags(target);
|
|
if (targetFlags & 111551 /* Value */) {
|
|
const moduleName = getFirstIdentifier(node.moduleReference);
|
|
if (!(resolveEntityName(moduleName, 111551 /* Value */ | 1920 /* Namespace */).flags & 1920 /* Namespace */)) {
|
|
error(moduleName, Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, declarationNameToString(moduleName));
|
|
}
|
|
}
|
|
if (targetFlags & 788968 /* Type */) {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Import_name_cannot_be_0);
|
|
}
|
|
}
|
|
if (node.isTypeOnly) {
|
|
grammarErrorOnNode(node, Diagnostics.An_import_alias_cannot_use_import_type);
|
|
}
|
|
} else {
|
|
if (moduleKind >= 5 /* ES2015 */ && getSourceFileOfNode(node).impliedNodeFormat === void 0 && !node.isTypeOnly && !(node.flags & 16777216 /* Ambient */)) {
|
|
grammarErrorOnNode(node, 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, isInJSFile(node) ? Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasSyntacticModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_export_declaration_cannot_have_modifiers);
|
|
}
|
|
if (node.moduleSpecifier && node.exportClause && isNamedExports(node.exportClause) && length(node.exportClause.elements) && languageVersion === 0 /* ES3 */) {
|
|
checkExternalEmitHelpers(node, 4194304 /* CreateBinding */);
|
|
}
|
|
checkGrammarExportDeclaration(node);
|
|
if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
|
|
if (node.exportClause && !isNamespaceExport(node.exportClause)) {
|
|
forEach(node.exportClause.elements, checkExportSpecifier);
|
|
const inAmbientExternalModule = node.parent.kind === 265 /* ModuleBlock */ && isAmbientModule(node.parent.parent);
|
|
const inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 265 /* ModuleBlock */ && !node.moduleSpecifier && node.flags & 16777216 /* Ambient */;
|
|
if (node.parent.kind !== 308 /* SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) {
|
|
error(node, Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
|
|
}
|
|
} else {
|
|
const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) {
|
|
error(node.moduleSpecifier, Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
|
|
} else if (node.exportClause) {
|
|
checkAliasSymbol(node.exportClause);
|
|
}
|
|
if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
if (node.exportClause) {
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
checkExternalEmitHelpers(node, 65536 /* ImportStar */);
|
|
}
|
|
} else {
|
|
checkExternalEmitHelpers(node, 32768 /* ExportStar */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkAssertClause(node);
|
|
}
|
|
function checkGrammarExportDeclaration(node) {
|
|
var _a2;
|
|
if (node.isTypeOnly) {
|
|
if (((_a2 = node.exportClause) == null ? void 0 : _a2.kind) === 276 /* NamedExports */) {
|
|
return checkGrammarNamedImportsOrExports(node.exportClause);
|
|
} else {
|
|
return grammarErrorOnNode(node, Diagnostics.Only_named_exports_may_use_export_type);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarModuleElementContext(node, errorMessage) {
|
|
const isInAppropriateContext = node.parent.kind === 308 /* SourceFile */ || node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 264 /* ModuleDeclaration */;
|
|
if (!isInAppropriateContext) {
|
|
grammarErrorOnFirstToken(node, errorMessage);
|
|
}
|
|
return !isInAppropriateContext;
|
|
}
|
|
function importClauseContainsReferencedImport(importClause) {
|
|
return forEachImportClauseDeclaration(importClause, (declaration) => {
|
|
return !!getSymbolOfNode(declaration).isReferenced;
|
|
});
|
|
}
|
|
function importClauseContainsConstEnumUsedAsValue(importClause) {
|
|
return forEachImportClauseDeclaration(importClause, (declaration) => {
|
|
return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
|
|
});
|
|
}
|
|
function canConvertImportDeclarationToTypeOnly(statement) {
|
|
return isImportDeclaration(statement) && statement.importClause && !statement.importClause.isTypeOnly && importClauseContainsReferencedImport(statement.importClause) && !isReferencedAliasDeclaration(statement.importClause, true) && !importClauseContainsConstEnumUsedAsValue(statement.importClause);
|
|
}
|
|
function canConvertImportEqualsDeclarationToTypeOnly(statement) {
|
|
return isImportEqualsDeclaration(statement) && isExternalModuleReference(statement.moduleReference) && !statement.isTypeOnly && getSymbolOfNode(statement).isReferenced && !isReferencedAliasDeclaration(statement, false) && !getSymbolLinks(getSymbolOfNode(statement)).constEnumReferenced;
|
|
}
|
|
function checkImportsForTypeOnlyConversion(sourceFile) {
|
|
for (const statement of sourceFile.statements) {
|
|
if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) {
|
|
error(
|
|
statement,
|
|
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 (getEmitDeclarations(compilerOptions)) {
|
|
collectLinkedAliases(node.propertyName || node.name, true);
|
|
}
|
|
if (!node.parent.parent.moduleSpecifier) {
|
|
const exportedName = node.propertyName || node.name;
|
|
const symbol = resolveName(
|
|
exportedName,
|
|
exportedName.escapedText,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
|
|
void 0,
|
|
void 0,
|
|
true
|
|
);
|
|
if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
|
|
error(exportedName, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, idText(exportedName));
|
|
} else {
|
|
if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
|
|
markExportAsReferenced(node);
|
|
}
|
|
const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
|
|
if (!target || getAllSymbolFlags(target) & 111551 /* Value */) {
|
|
checkExpressionCached(node.propertyName || node.name);
|
|
}
|
|
}
|
|
} else {
|
|
if (getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && idText(node.propertyName || node.name) === "default") {
|
|
checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
|
|
}
|
|
}
|
|
}
|
|
function checkExportAssignment(node) {
|
|
const illegalContextMessage = node.isExportEquals ? Diagnostics.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration : Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration;
|
|
if (checkGrammarModuleElementContext(node, illegalContextMessage)) {
|
|
return;
|
|
}
|
|
const container = node.parent.kind === 308 /* SourceFile */ ? node.parent : node.parent.parent;
|
|
if (container.kind === 264 /* ModuleDeclaration */ && !isAmbientModule(container)) {
|
|
if (node.isExportEquals) {
|
|
error(node, Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
|
|
} else {
|
|
error(node, Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
|
|
}
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_export_assignment_cannot_have_modifiers);
|
|
}
|
|
const typeAnnotationNode = getEffectiveTypeAnnotationNode(node);
|
|
if (typeAnnotationNode) {
|
|
checkTypeAssignableTo(checkExpressionCached(node.expression), getTypeFromTypeNode(typeAnnotationNode), node.expression);
|
|
}
|
|
if (node.expression.kind === 79 /* Identifier */) {
|
|
const id = node.expression;
|
|
const sym = resolveEntityName(id, 67108863 /* All */, true, true, node);
|
|
if (sym) {
|
|
markAliasReferenced(sym, id);
|
|
const target = sym.flags & 2097152 /* Alias */ ? resolveAlias(sym) : sym;
|
|
if (getAllSymbolFlags(target) & 111551 /* Value */) {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
} else {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
if (getEmitDeclarations(compilerOptions)) {
|
|
collectLinkedAliases(node.expression, true);
|
|
}
|
|
} else {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
checkExternalModuleExports(container);
|
|
if (node.flags & 16777216 /* Ambient */ && !isEntityNameExpression(node.expression)) {
|
|
grammarErrorOnNode(node.expression, Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
|
|
}
|
|
if (node.isExportEquals && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (moduleKind >= 5 /* ES2015 */ && getSourceFileOfNode(node).impliedNodeFormat !== 1 /* CommonJS */) {
|
|
grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
|
|
} else if (moduleKind === 4 /* System */) {
|
|
grammarErrorOnNode(node, Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
|
|
}
|
|
}
|
|
}
|
|
function hasExportedMembers(moduleSymbol) {
|
|
return forEachEntry(moduleSymbol.exports, (_, id) => id !== "export=");
|
|
}
|
|
function checkExternalModuleExports(node) {
|
|
const moduleSymbol = getSymbolOfNode(node);
|
|
const links = getSymbolLinks(moduleSymbol);
|
|
if (!links.exportsChecked) {
|
|
const exportEqualsSymbol = moduleSymbol.exports.get("export=");
|
|
if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
|
|
const declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
|
|
if (declaration && !isTopLevelInExternalModuleAugmentation(declaration) && !isInJSFile(declaration)) {
|
|
error(declaration, Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
|
|
}
|
|
}
|
|
const exports = getExportsOfModule(moduleSymbol);
|
|
if (exports) {
|
|
exports.forEach(({ declarations, flags }, id) => {
|
|
if (id === "__export") {
|
|
return;
|
|
}
|
|
if (flags & (1920 /* Namespace */ | 384 /* Enum */)) {
|
|
return;
|
|
}
|
|
const exportedDeclarationsCount = countWhere(declarations, and(isNotOverloadAndNotAccessor, not(isInterfaceDeclaration)));
|
|
if (flags & 524288 /* TypeAlias */ && exportedDeclarationsCount <= 2) {
|
|
return;
|
|
}
|
|
if (exportedDeclarationsCount > 1) {
|
|
if (!isDuplicatedCommonJSExport(declarations)) {
|
|
for (const declaration of declarations) {
|
|
if (isNotOverload(declaration)) {
|
|
diagnostics.add(createDiagnosticForNode(declaration, Diagnostics.Cannot_redeclare_exported_variable_0, unescapeLeadingUnderscores(id)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
links.exportsChecked = true;
|
|
}
|
|
}
|
|
function isDuplicatedCommonJSExport(declarations) {
|
|
return declarations && declarations.length > 1 && declarations.every((d) => isInJSFile(d) && isAccessExpression(d) && (isExportsIdentifier(d.expression) || isModuleExportsAccessExpression(d.expression)));
|
|
}
|
|
function checkSourceElement(node) {
|
|
if (node) {
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
checkSourceElementWorker(node);
|
|
currentNode = saveCurrentNode;
|
|
}
|
|
}
|
|
function checkSourceElementWorker(node) {
|
|
forEach(node.jsDoc, ({ comment, tags }) => {
|
|
checkJSDocCommentWorker(comment);
|
|
forEach(tags, (tag) => {
|
|
checkJSDocCommentWorker(tag.comment);
|
|
if (isInJSFile(node)) {
|
|
checkSourceElement(tag);
|
|
}
|
|
});
|
|
});
|
|
const kind = node.kind;
|
|
if (cancellationToken) {
|
|
switch (kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
if (kind >= 240 /* FirstStatement */ && kind <= 256 /* LastStatement */ && node.flowNode && !isReachableFlowNode(node.flowNode)) {
|
|
errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, Diagnostics.Unreachable_code_detected);
|
|
}
|
|
switch (kind) {
|
|
case 165 /* TypeParameter */:
|
|
return checkTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return checkParameter(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return checkPropertyDeclaration(node);
|
|
case 168 /* PropertySignature */:
|
|
return checkPropertySignature(node);
|
|
case 182 /* ConstructorType */:
|
|
case 181 /* FunctionType */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return checkSignatureDeclaration(node);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return checkMethodDeclaration(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return checkClassStaticBlockDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return checkConstructorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return checkAccessorDeclaration(node);
|
|
case 180 /* TypeReference */:
|
|
return checkTypeReferenceNode(node);
|
|
case 179 /* TypePredicate */:
|
|
return checkTypePredicate(node);
|
|
case 183 /* TypeQuery */:
|
|
return checkTypeQuery(node);
|
|
case 184 /* TypeLiteral */:
|
|
return checkTypeLiteral(node);
|
|
case 185 /* ArrayType */:
|
|
return checkArrayType(node);
|
|
case 186 /* TupleType */:
|
|
return checkTupleType(node);
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return checkUnionOrIntersectionType(node);
|
|
case 193 /* ParenthesizedType */:
|
|
case 187 /* OptionalType */:
|
|
case 188 /* RestType */:
|
|
return checkSourceElement(node.type);
|
|
case 194 /* ThisType */:
|
|
return checkThisType(node);
|
|
case 195 /* TypeOperator */:
|
|
return checkTypeOperator(node);
|
|
case 191 /* ConditionalType */:
|
|
return checkConditionalType(node);
|
|
case 192 /* InferType */:
|
|
return checkInferType(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return checkTemplateLiteralType(node);
|
|
case 202 /* ImportType */:
|
|
return checkImportType(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return checkNamedTupleMember(node);
|
|
case 331 /* JSDocAugmentsTag */:
|
|
return checkJSDocAugmentsTag(node);
|
|
case 332 /* JSDocImplementsTag */:
|
|
return checkJSDocImplementsTag(node);
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return checkJSDocTypeAliasTag(node);
|
|
case 347 /* JSDocTemplateTag */:
|
|
return checkJSDocTemplateTag(node);
|
|
case 346 /* JSDocTypeTag */:
|
|
return checkJSDocTypeTag(node);
|
|
case 327 /* JSDocLink */:
|
|
case 328 /* JSDocLinkCode */:
|
|
case 329 /* JSDocLinkPlain */:
|
|
return checkJSDocLinkLikeTag(node);
|
|
case 343 /* JSDocParameterTag */:
|
|
return checkJSDocParameterTag(node);
|
|
case 350 /* JSDocPropertyTag */:
|
|
return checkJSDocPropertyTag(node);
|
|
case 320 /* JSDocFunctionType */:
|
|
checkJSDocFunctionType(node);
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 317 /* JSDocNullableType */:
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
checkJSDocTypeIsInJsFile(node);
|
|
forEachChild(node, checkSourceElement);
|
|
return;
|
|
case 321 /* JSDocVariadicType */:
|
|
checkJSDocVariadicType(node);
|
|
return;
|
|
case 312 /* JSDocTypeExpression */:
|
|
return checkSourceElement(node.type);
|
|
case 336 /* JSDocPublicTag */:
|
|
case 338 /* JSDocProtectedTag */:
|
|
case 337 /* JSDocPrivateTag */:
|
|
return checkJSDocAccessibilityModifiers(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return checkIndexedAccessType(node);
|
|
case 197 /* MappedType */:
|
|
return checkMappedType(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return checkFunctionDeclaration(node);
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
return checkBlock(node);
|
|
case 240 /* VariableStatement */:
|
|
return checkVariableStatement(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return checkExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return checkIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return checkDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return checkWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return checkForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return checkForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return checkForOfStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
case 249 /* BreakStatement */:
|
|
return checkBreakOrContinueStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return checkReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return checkWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return checkSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return checkLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return checkThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return checkTryStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return checkVariableDeclaration(node);
|
|
case 205 /* BindingElement */:
|
|
return checkBindingElement(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return checkClassDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return checkInterfaceDeclaration(node);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return checkTypeAliasDeclaration(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return checkEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return checkModuleDeclaration(node);
|
|
case 269 /* ImportDeclaration */:
|
|
return checkImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return checkImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return checkExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return checkExportAssignment(node);
|
|
case 239 /* EmptyStatement */:
|
|
case 256 /* DebuggerStatement */:
|
|
checkGrammarStatementInAmbientContext(node);
|
|
return;
|
|
case 279 /* MissingDeclaration */:
|
|
return checkMissingDeclaration(node);
|
|
}
|
|
}
|
|
function checkJSDocCommentWorker(node) {
|
|
if (isArray(node)) {
|
|
forEach(node, (tag) => {
|
|
if (isJSDocLinkLike(tag)) {
|
|
checkSourceElement(tag);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkJSDocTypeIsInJsFile(node) {
|
|
if (!isInJSFile(node)) {
|
|
grammarErrorOnNode(node, Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
|
|
}
|
|
}
|
|
function checkJSDocVariadicType(node) {
|
|
checkJSDocTypeIsInJsFile(node);
|
|
checkSourceElement(node.type);
|
|
const { parent } = node;
|
|
if (isParameter(parent) && isJSDocFunctionType(parent.parent)) {
|
|
if (last(parent.parent.parameters) !== parent) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
return;
|
|
}
|
|
if (!isJSDocTypeExpression(parent)) {
|
|
error(node, Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
|
|
}
|
|
const paramTag = node.parent.parent;
|
|
if (!isJSDocParameterTag(paramTag)) {
|
|
error(node, Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
|
|
return;
|
|
}
|
|
const param = getParameterSymbolFromJSDoc(paramTag);
|
|
if (!param) {
|
|
return;
|
|
}
|
|
const host2 = getHostSignatureFromJSDoc(paramTag);
|
|
if (!host2 || last(host2.parameters).symbol !== param) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
}
|
|
function getTypeFromJSDocVariadicType(node) {
|
|
const type = getTypeFromTypeNode(node.type);
|
|
const { parent } = node;
|
|
const paramTag = node.parent.parent;
|
|
if (isJSDocTypeExpression(node.parent) && isJSDocParameterTag(paramTag)) {
|
|
const host2 = getHostSignatureFromJSDoc(paramTag);
|
|
const isCallbackTag = isJSDocCallbackTag(paramTag.parent.parent);
|
|
if (host2 || isCallbackTag) {
|
|
const lastParamDeclaration = isCallbackTag ? lastOrUndefined(paramTag.parent.parent.typeExpression.parameters) : lastOrUndefined(host2.parameters);
|
|
const symbol = getParameterSymbolFromJSDoc(paramTag);
|
|
if (!lastParamDeclaration || symbol && lastParamDeclaration.symbol === symbol && isRestParameter(lastParamDeclaration)) {
|
|
return createArrayType(type);
|
|
}
|
|
}
|
|
}
|
|
if (isParameter(parent) && isJSDocFunctionType(parent.parent)) {
|
|
return createArrayType(type);
|
|
}
|
|
return addOptionality(type);
|
|
}
|
|
function checkNodeDeferred(node) {
|
|
const enclosingFile = getSourceFileOfNode(node);
|
|
const links = getNodeLinks(enclosingFile);
|
|
if (!(links.flags & 1 /* TypeChecked */)) {
|
|
links.deferredNodes || (links.deferredNodes = /* @__PURE__ */ new Set());
|
|
links.deferredNodes.add(node);
|
|
}
|
|
}
|
|
function checkDeferredNodes(context) {
|
|
const links = getNodeLinks(context);
|
|
if (links.deferredNodes) {
|
|
links.deferredNodes.forEach(checkDeferredNode);
|
|
}
|
|
}
|
|
function checkDeferredNode(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 167 /* Decorator */:
|
|
case 283 /* JsxOpeningElement */:
|
|
resolveUntypedCall(node);
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
checkFunctionExpressionOrObjectLiteralMethodDeferred(node);
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
checkAccessorDeclaration(node);
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
checkClassExpressionDeferred(node);
|
|
break;
|
|
case 165 /* TypeParameter */:
|
|
checkTypeParameterDeferred(node);
|
|
break;
|
|
case 282 /* JsxSelfClosingElement */:
|
|
checkJsxSelfClosingElementDeferred(node);
|
|
break;
|
|
case 281 /* JsxElement */:
|
|
checkJsxElementDeferred(node);
|
|
break;
|
|
}
|
|
currentNode = saveCurrentNode;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function checkSourceFile(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkSourceFile", { path: node.path }, true);
|
|
mark("beforeCheck");
|
|
checkSourceFileWorker(node);
|
|
mark("afterCheck");
|
|
measure("Check", "beforeCheck", "afterCheck");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function unusedIsError(kind, isAmbient) {
|
|
if (isAmbient) {
|
|
return false;
|
|
}
|
|
switch (kind) {
|
|
case 0 /* Local */:
|
|
return !!compilerOptions.noUnusedLocals;
|
|
case 1 /* Parameter */:
|
|
return !!compilerOptions.noUnusedParameters;
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function getPotentiallyUnusedIdentifiers(sourceFile) {
|
|
return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || emptyArray;
|
|
}
|
|
function checkSourceFileWorker(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!(links.flags & 1 /* TypeChecked */)) {
|
|
if (skipTypeChecking(node, compilerOptions, host)) {
|
|
return;
|
|
}
|
|
checkGrammarSourceFile(node);
|
|
clear(potentialThisCollisions);
|
|
clear(potentialNewTargetCollisions);
|
|
clear(potentialWeakMapSetCollisions);
|
|
clear(potentialReflectCollisions);
|
|
clear(potentialUnusedRenamedBindingElementsInTypes);
|
|
forEach(node.statements, checkSourceElement);
|
|
checkSourceElement(node.endOfFileToken);
|
|
checkDeferredNodes(node);
|
|
if (isExternalOrCommonJsModule(node)) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
addLazyDiagnostic(() => {
|
|
if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
|
|
checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), (containingNode, kind, diag2) => {
|
|
if (!containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
});
|
|
}
|
|
if (!node.isDeclarationFile) {
|
|
checkPotentialUncheckedRenamedBindingElementsInTypes();
|
|
}
|
|
});
|
|
if (compilerOptions.importsNotUsedAsValues === 2 /* Error */ && !node.isDeclarationFile && isExternalModule(node)) {
|
|
checkImportsForTypeOnlyConversion(node);
|
|
}
|
|
if (isExternalOrCommonJsModule(node)) {
|
|
checkExternalModuleExports(node);
|
|
}
|
|
if (potentialThisCollisions.length) {
|
|
forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope);
|
|
clear(potentialThisCollisions);
|
|
}
|
|
if (potentialNewTargetCollisions.length) {
|
|
forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope);
|
|
clear(potentialNewTargetCollisions);
|
|
}
|
|
if (potentialWeakMapSetCollisions.length) {
|
|
forEach(potentialWeakMapSetCollisions, checkWeakMapSetCollision);
|
|
clear(potentialWeakMapSetCollisions);
|
|
}
|
|
if (potentialReflectCollisions.length) {
|
|
forEach(potentialReflectCollisions, checkReflectCollision);
|
|
clear(potentialReflectCollisions);
|
|
}
|
|
links.flags |= 1 /* TypeChecked */;
|
|
}
|
|
}
|
|
function getDiagnostics(sourceFile, ct) {
|
|
try {
|
|
cancellationToken = ct;
|
|
return getDiagnosticsWorker(sourceFile);
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
}
|
|
function ensurePendingDiagnosticWorkComplete() {
|
|
for (const cb of deferredDiagnosticsCallbacks) {
|
|
cb();
|
|
}
|
|
deferredDiagnosticsCallbacks = [];
|
|
}
|
|
function checkSourceFileWithEagerDiagnostics(sourceFile) {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
const oldAddLazyDiagnostics = addLazyDiagnostic;
|
|
addLazyDiagnostic = (cb) => cb();
|
|
checkSourceFile(sourceFile);
|
|
addLazyDiagnostic = oldAddLazyDiagnostics;
|
|
}
|
|
function getDiagnosticsWorker(sourceFile) {
|
|
if (sourceFile) {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
const previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
|
|
const previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length;
|
|
checkSourceFileWithEagerDiagnostics(sourceFile);
|
|
const semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName);
|
|
const currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
|
|
if (currentGlobalDiagnostics !== previousGlobalDiagnostics) {
|
|
const deferredGlobalDiagnostics = relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, compareDiagnostics);
|
|
return concatenate(deferredGlobalDiagnostics, semanticDiagnostics);
|
|
} else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) {
|
|
return concatenate(currentGlobalDiagnostics, semanticDiagnostics);
|
|
}
|
|
return semanticDiagnostics;
|
|
}
|
|
forEach(host.getSourceFiles(), checkSourceFileWithEagerDiagnostics);
|
|
return diagnostics.getDiagnostics();
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
return diagnostics.getGlobalDiagnostics();
|
|
}
|
|
function getSymbolsInScope(location, meaning) {
|
|
if (location.flags & 33554432 /* InWithStatement */) {
|
|
return [];
|
|
}
|
|
const symbols = createSymbolTable();
|
|
let isStaticSymbol = false;
|
|
populateSymbols();
|
|
symbols.delete("this" /* This */);
|
|
return symbolsToArray(symbols);
|
|
function populateSymbols() {
|
|
while (location) {
|
|
if (location.locals && !isGlobalSourceFile(location)) {
|
|
copySymbols(location.locals, meaning);
|
|
}
|
|
switch (location.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalModule(location))
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
copyLocallyVisibleExportSymbols(getSymbolOfNode(location).exports, meaning & 2623475 /* ModuleMember */);
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* EnumMember */);
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
const className = location.name;
|
|
if (className) {
|
|
copySymbol(location.symbol, meaning);
|
|
}
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
if (!isStaticSymbol) {
|
|
copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & 788968 /* Type */);
|
|
}
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
const funcName = location.name;
|
|
if (funcName) {
|
|
copySymbol(location.symbol, meaning);
|
|
}
|
|
break;
|
|
}
|
|
if (introducesArgumentsExoticObject(location)) {
|
|
copySymbol(argumentsSymbol, meaning);
|
|
}
|
|
isStaticSymbol = isStatic(location);
|
|
location = location.parent;
|
|
}
|
|
copySymbols(globals, meaning);
|
|
}
|
|
function copySymbol(symbol, meaning2) {
|
|
if (getCombinedLocalAndExportSymbolFlags(symbol) & meaning2) {
|
|
const id = symbol.escapedName;
|
|
if (!symbols.has(id)) {
|
|
symbols.set(id, symbol);
|
|
}
|
|
}
|
|
}
|
|
function copySymbols(source, meaning2) {
|
|
if (meaning2) {
|
|
source.forEach((symbol) => {
|
|
copySymbol(symbol, meaning2);
|
|
});
|
|
}
|
|
}
|
|
function copyLocallyVisibleExportSymbols(source, meaning2) {
|
|
if (meaning2) {
|
|
source.forEach((symbol) => {
|
|
if (!getDeclarationOfKind(symbol, 278 /* ExportSpecifier */) && !getDeclarationOfKind(symbol, 277 /* NamespaceExport */)) {
|
|
copySymbol(symbol, meaning2);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function isTypeDeclarationName(name) {
|
|
return name.kind === 79 /* Identifier */ && isTypeDeclaration(name.parent) && getNameOfDeclaration(name.parent) === name;
|
|
}
|
|
function isTypeReferenceIdentifier(node) {
|
|
while (node.parent.kind === 163 /* QualifiedName */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 180 /* TypeReference */;
|
|
}
|
|
function isHeritageClauseElementIdentifier(node) {
|
|
while (node.parent.kind === 208 /* PropertyAccessExpression */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
function forEachEnclosingClass(node, callback) {
|
|
let result;
|
|
while (true) {
|
|
node = getContainingClass(node);
|
|
if (!node)
|
|
break;
|
|
if (result = callback(node))
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
function isNodeUsedDuringClassInitialization(node) {
|
|
return !!findAncestor(node, (element) => {
|
|
if (isConstructorDeclaration(element) && nodeIsPresent(element.body) || isPropertyDeclaration(element)) {
|
|
return true;
|
|
} else if (isClassLike(element) || isFunctionLikeDeclaration(element)) {
|
|
return "quit";
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function isNodeWithinClass(node, classDeclaration) {
|
|
return !!forEachEnclosingClass(node, (n) => n === classDeclaration);
|
|
}
|
|
function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) {
|
|
while (nodeOnRightSide.parent.kind === 163 /* QualifiedName */) {
|
|
nodeOnRightSide = nodeOnRightSide.parent;
|
|
}
|
|
if (nodeOnRightSide.parent.kind === 268 /* ImportEqualsDeclaration */) {
|
|
return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : void 0;
|
|
}
|
|
if (nodeOnRightSide.parent.kind === 274 /* ExportAssignment */) {
|
|
return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isInRightSideOfImportOrExportAssignment(node) {
|
|
return getLeftSideOfImportEqualsOrExportAssignment(node) !== void 0;
|
|
}
|
|
function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) {
|
|
const specialPropertyAssignmentKind = getAssignmentDeclarationKind(entityName.parent.parent);
|
|
switch (specialPropertyAssignmentKind) {
|
|
case 1 /* ExportsProperty */:
|
|
case 3 /* PrototypeProperty */:
|
|
return getSymbolOfNode(entityName.parent);
|
|
case 4 /* ThisProperty */:
|
|
case 2 /* ModuleExports */:
|
|
case 5 /* Property */:
|
|
return getSymbolOfNode(entityName.parent.parent);
|
|
}
|
|
}
|
|
function isImportTypeQualifierPart(node) {
|
|
let parent = node.parent;
|
|
while (isQualifiedName(parent)) {
|
|
node = parent;
|
|
parent = parent.parent;
|
|
}
|
|
if (parent && parent.kind === 202 /* ImportType */ && parent.qualifier === node) {
|
|
return parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSymbolOfNameOrPropertyAccessExpression(name) {
|
|
if (isDeclarationName(name)) {
|
|
return getSymbolOfNode(name.parent);
|
|
}
|
|
if (isInJSFile(name) && name.parent.kind === 208 /* PropertyAccessExpression */ && name.parent === name.parent.parent.left) {
|
|
if (!isPrivateIdentifier(name) && !isJSDocMemberName(name)) {
|
|
const specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name);
|
|
if (specialPropertyAssignmentSymbol) {
|
|
return specialPropertyAssignmentSymbol;
|
|
}
|
|
}
|
|
}
|
|
if (name.parent.kind === 274 /* ExportAssignment */ && isEntityNameExpression(name)) {
|
|
const success = resolveEntityName(
|
|
name,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
|
|
true
|
|
);
|
|
if (success && success !== unknownSymbol) {
|
|
return success;
|
|
}
|
|
} else if (isEntityName(name) && isInRightSideOfImportOrExportAssignment(name)) {
|
|
const importEqualsDeclaration = getAncestor(name, 268 /* ImportEqualsDeclaration */);
|
|
Debug.assert(importEqualsDeclaration !== void 0);
|
|
return getSymbolOfPartOfRightHandSideOfImportEquals(name, true);
|
|
}
|
|
if (isEntityName(name)) {
|
|
const possibleImportNode = isImportTypeQualifierPart(name);
|
|
if (possibleImportNode) {
|
|
getTypeFromTypeNode(possibleImportNode);
|
|
const sym = getNodeLinks(name).resolvedSymbol;
|
|
return sym === unknownSymbol ? void 0 : sym;
|
|
}
|
|
}
|
|
while (isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(name)) {
|
|
name = name.parent;
|
|
}
|
|
if (isHeritageClauseElementIdentifier(name)) {
|
|
let meaning = 0 /* None */;
|
|
if (name.parent.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
meaning = 788968 /* Type */;
|
|
if (isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) {
|
|
meaning |= 111551 /* Value */;
|
|
}
|
|
} else {
|
|
meaning = 1920 /* Namespace */;
|
|
}
|
|
meaning |= 2097152 /* Alias */;
|
|
const entityNameSymbol = isEntityNameExpression(name) ? resolveEntityName(name, meaning) : void 0;
|
|
if (entityNameSymbol) {
|
|
return entityNameSymbol;
|
|
}
|
|
}
|
|
if (name.parent.kind === 343 /* JSDocParameterTag */) {
|
|
return getParameterSymbolFromJSDoc(name.parent);
|
|
}
|
|
if (name.parent.kind === 165 /* TypeParameter */ && name.parent.parent.kind === 347 /* JSDocTemplateTag */) {
|
|
Debug.assert(!isInJSFile(name));
|
|
const typeParameter = getTypeParameterFromJsDoc(name.parent);
|
|
return typeParameter && typeParameter.symbol;
|
|
}
|
|
if (isExpressionNode(name)) {
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
const isJSDoc2 = findAncestor(name, or(isJSDocLinkLike, isJSDocNameReference, isJSDocMemberName));
|
|
const meaning = isJSDoc2 ? 788968 /* Type */ | 1920 /* Namespace */ | 111551 /* Value */ : 111551 /* Value */;
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) {
|
|
const symbol = getIntrinsicTagSymbol(name.parent);
|
|
return symbol === unknownSymbol ? void 0 : symbol;
|
|
}
|
|
const result = resolveEntityName(name, meaning, false, true, getHostSignatureFromJSDoc(name));
|
|
if (!result && isJSDoc2) {
|
|
const container = findAncestor(name, or(isClassLike, isInterfaceDeclaration));
|
|
if (container) {
|
|
return resolveJSDocMemberName(name, false, getSymbolOfNode(container));
|
|
}
|
|
}
|
|
if (result && isJSDoc2) {
|
|
const container = getJSDocHost(name);
|
|
if (container && isEnumMember(container) && container === result.valueDeclaration) {
|
|
return resolveEntityName(name, meaning, true, true, getSourceFileOfNode(container)) || result;
|
|
}
|
|
}
|
|
return result;
|
|
} else if (isPrivateIdentifier(name)) {
|
|
return getSymbolForPrivateIdentifierExpression(name);
|
|
} else if (name.kind === 208 /* PropertyAccessExpression */ || name.kind === 163 /* QualifiedName */) {
|
|
const links = getNodeLinks(name);
|
|
if (links.resolvedSymbol) {
|
|
return links.resolvedSymbol;
|
|
}
|
|
if (name.kind === 208 /* PropertyAccessExpression */) {
|
|
checkPropertyAccessExpression(name, 0 /* Normal */);
|
|
if (!links.resolvedSymbol) {
|
|
const expressionType = checkExpressionCached(name.expression);
|
|
const infos = getApplicableIndexInfos(expressionType, getLiteralTypeFromPropertyName(name.name));
|
|
if (infos.length && expressionType.members) {
|
|
const resolved = resolveStructuredTypeMembers(expressionType);
|
|
const symbol = resolved.members.get("__index" /* Index */);
|
|
if (infos === getIndexInfosOfType(expressionType)) {
|
|
links.resolvedSymbol = symbol;
|
|
} else if (symbol) {
|
|
const symbolLinks2 = getSymbolLinks(symbol);
|
|
const declarationList = mapDefined(infos, (i) => i.declaration);
|
|
const nodeListId = map(declarationList, getNodeId).join(",");
|
|
if (!symbolLinks2.filteredIndexSymbolCache) {
|
|
symbolLinks2.filteredIndexSymbolCache = /* @__PURE__ */ new Map();
|
|
}
|
|
if (symbolLinks2.filteredIndexSymbolCache.has(nodeListId)) {
|
|
links.resolvedSymbol = symbolLinks2.filteredIndexSymbolCache.get(nodeListId);
|
|
} else {
|
|
const copy = createSymbol(131072 /* Signature */, "__index" /* Index */);
|
|
copy.declarations = mapDefined(infos, (i) => i.declaration);
|
|
copy.parent = expressionType.aliasSymbol ? expressionType.aliasSymbol : expressionType.symbol ? expressionType.symbol : getSymbolAtLocation(copy.declarations[0].parent);
|
|
symbolLinks2.filteredIndexSymbolCache.set(nodeListId, copy);
|
|
links.resolvedSymbol = symbolLinks2.filteredIndexSymbolCache.get(nodeListId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
checkQualifiedName(name, 0 /* Normal */);
|
|
}
|
|
if (!links.resolvedSymbol && isJSDoc2 && isQualifiedName(name)) {
|
|
return resolveJSDocMemberName(name);
|
|
}
|
|
return links.resolvedSymbol;
|
|
} else if (isJSDocMemberName(name)) {
|
|
return resolveJSDocMemberName(name);
|
|
}
|
|
} else if (isTypeReferenceIdentifier(name)) {
|
|
const meaning = name.parent.kind === 180 /* TypeReference */ ? 788968 /* Type */ : 1920 /* Namespace */;
|
|
const symbol = resolveEntityName(name, meaning, false, true);
|
|
return symbol && symbol !== unknownSymbol ? symbol : getUnresolvedSymbolForEntityName(name);
|
|
}
|
|
if (name.parent.kind === 179 /* TypePredicate */) {
|
|
return resolveEntityName(name, 1 /* FunctionScopedVariable */);
|
|
}
|
|
return void 0;
|
|
}
|
|
function resolveJSDocMemberName(name, ignoreErrors, container) {
|
|
if (isEntityName(name)) {
|
|
const meaning = 788968 /* Type */ | 1920 /* Namespace */ | 111551 /* Value */;
|
|
let symbol = resolveEntityName(name, meaning, ignoreErrors, true, getHostSignatureFromJSDoc(name));
|
|
if (!symbol && isIdentifier(name) && container) {
|
|
symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(container), name.escapedText, meaning));
|
|
}
|
|
if (symbol) {
|
|
return symbol;
|
|
}
|
|
}
|
|
const left = isIdentifier(name) ? container : resolveJSDocMemberName(name.left, ignoreErrors, container);
|
|
const right = isIdentifier(name) ? name.escapedText : name.right.escapedText;
|
|
if (left) {
|
|
const proto = left.flags & 111551 /* Value */ && getPropertyOfType(getTypeOfSymbol(left), "prototype");
|
|
const t = proto ? getTypeOfSymbol(proto) : getDeclaredTypeOfSymbol(left);
|
|
return getPropertyOfType(t, right);
|
|
}
|
|
}
|
|
function getSymbolAtLocation(node, ignoreErrors) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return isExternalModule(node) ? getMergedSymbol(node.symbol) : void 0;
|
|
}
|
|
const { parent } = node;
|
|
const grandParent = parent.parent;
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
if (isDeclarationNameOrImportPropertyName(node)) {
|
|
const parentSymbol = getSymbolOfNode(parent);
|
|
return isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node ? getImmediateAliasedSymbol(parentSymbol) : parentSymbol;
|
|
} else if (isLiteralComputedPropertyDeclarationName(node)) {
|
|
return getSymbolOfNode(parent.parent);
|
|
}
|
|
if (node.kind === 79 /* Identifier */) {
|
|
if (isInRightSideOfImportOrExportAssignment(node)) {
|
|
return getSymbolOfNameOrPropertyAccessExpression(node);
|
|
} else if (parent.kind === 205 /* BindingElement */ && grandParent.kind === 203 /* ObjectBindingPattern */ && node === parent.propertyName) {
|
|
const typeOfPattern = getTypeOfNode(grandParent);
|
|
const propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText);
|
|
if (propertyDeclaration) {
|
|
return propertyDeclaration;
|
|
}
|
|
} else if (isMetaProperty(parent) && parent.name === node) {
|
|
if (parent.keywordToken === 103 /* NewKeyword */ && idText(node) === "target") {
|
|
return checkNewTargetMetaProperty(parent).symbol;
|
|
}
|
|
if (parent.keywordToken === 100 /* ImportKeyword */ && idText(node) === "meta") {
|
|
return getGlobalImportMetaExpressionType().members.get("meta");
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 163 /* QualifiedName */:
|
|
if (!isThisInTypeQuery(node)) {
|
|
return getSymbolOfNameOrPropertyAccessExpression(node);
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
const container = getThisContainer(node, false);
|
|
if (isFunctionLike(container)) {
|
|
const sig = getSignatureFromDeclaration(container);
|
|
if (sig.thisParameter) {
|
|
return sig.thisParameter;
|
|
}
|
|
}
|
|
if (isInExpressionContext(node)) {
|
|
return checkExpression(node).symbol;
|
|
}
|
|
case 194 /* ThisType */:
|
|
return getTypeFromThisTypeNode(node).symbol;
|
|
case 106 /* SuperKeyword */:
|
|
return checkExpression(node).symbol;
|
|
case 135 /* ConstructorKeyword */:
|
|
const constructorDeclaration = node.parent;
|
|
if (constructorDeclaration && constructorDeclaration.kind === 173 /* Constructor */) {
|
|
return constructorDeclaration.parent.symbol;
|
|
}
|
|
return void 0;
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
if (isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node || (node.parent.kind === 269 /* ImportDeclaration */ || node.parent.kind === 275 /* ExportDeclaration */) && node.parent.moduleSpecifier === node || (isInJSFile(node) && isRequireCall(node.parent, false) || isImportCall(node.parent)) || isLiteralTypeNode(node.parent) && isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent) {
|
|
return resolveExternalModuleName(node, node, ignoreErrors);
|
|
}
|
|
if (isCallExpression(parent) && isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) {
|
|
return getSymbolOfNode(parent);
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
const objectType = isElementAccessExpression(parent) ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : void 0 : isLiteralTypeNode(parent) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0;
|
|
return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text));
|
|
case 88 /* DefaultKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 38 /* EqualsGreaterThanToken */:
|
|
case 84 /* ClassKeyword */:
|
|
return getSymbolOfNode(node.parent);
|
|
case 202 /* ImportType */:
|
|
return isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : void 0;
|
|
case 93 /* ExportKeyword */:
|
|
return isExportAssignment(node.parent) ? Debug.checkDefined(node.parent.symbol) : void 0;
|
|
case 100 /* ImportKeyword */:
|
|
case 103 /* NewKeyword */:
|
|
return isMetaProperty(node.parent) ? checkMetaPropertyKeyword(node.parent).symbol : void 0;
|
|
case 233 /* MetaProperty */:
|
|
return checkExpression(node).symbol;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getIndexInfosAtLocation(node) {
|
|
if (isIdentifier(node) && isPropertyAccessExpression(node.parent) && node.parent.name === node) {
|
|
const keyType = getLiteralTypeFromPropertyName(node);
|
|
const objectType = getTypeOfExpression(node.parent.expression);
|
|
const objectTypes = objectType.flags & 1048576 /* Union */ ? objectType.types : [objectType];
|
|
return flatMap(objectTypes, (t) => filter(getIndexInfosOfType(t), (info) => isApplicableIndexType(keyType, info.keyType)));
|
|
}
|
|
return void 0;
|
|
}
|
|
function getShorthandAssignmentValueSymbol(location) {
|
|
if (location && location.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return resolveEntityName(location.name, 111551 /* Value */ | 2097152 /* Alias */);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExportSpecifierLocalTargetSymbol(node) {
|
|
if (isExportSpecifier(node)) {
|
|
return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node.propertyName || node.name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
} else {
|
|
return resolveEntityName(node, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
}
|
|
}
|
|
function getTypeOfNode(node) {
|
|
if (isSourceFile(node) && !isExternalModule(node)) {
|
|
return errorType;
|
|
}
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return errorType;
|
|
}
|
|
const classDecl = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
|
|
const classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class));
|
|
if (isPartOfTypeNode(node)) {
|
|
const typeFromTypeNode = getTypeFromTypeNode(node);
|
|
return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode;
|
|
}
|
|
if (isExpressionNode(node)) {
|
|
return getRegularTypeOfExpression(node);
|
|
}
|
|
if (classType && !classDecl.isImplements) {
|
|
const baseType = firstOrUndefined(getBaseTypes(classType));
|
|
return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
|
|
}
|
|
if (isTypeDeclaration(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
return getDeclaredTypeOfSymbol(symbol);
|
|
}
|
|
if (isTypeDeclarationName(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
|
|
}
|
|
if (isDeclaration(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
return symbol ? getTypeOfSymbol(symbol) : errorType;
|
|
}
|
|
if (isDeclarationNameOrImportPropertyName(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (isBindingPattern(node)) {
|
|
return getTypeForVariableLikeDeclaration(node.parent, true, 0 /* Normal */) || errorType;
|
|
}
|
|
if (isInRightSideOfImportOrExportAssignment(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
const declaredType = getDeclaredTypeOfSymbol(symbol);
|
|
return !isErrorType(declaredType) ? declaredType : getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
if (isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
|
|
return checkMetaPropertyKeyword(node.parent);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getTypeOfAssignmentPattern(expr) {
|
|
Debug.assert(expr.kind === 207 /* ObjectLiteralExpression */ || expr.kind === 206 /* ArrayLiteralExpression */);
|
|
if (expr.parent.kind === 247 /* ForOfStatement */) {
|
|
const iteratedType = checkRightHandSideOfForOf(expr.parent);
|
|
return checkDestructuringAssignment(expr, iteratedType || errorType);
|
|
}
|
|
if (expr.parent.kind === 223 /* BinaryExpression */) {
|
|
const iteratedType = getTypeOfExpression(expr.parent.right);
|
|
return checkDestructuringAssignment(expr, iteratedType || errorType);
|
|
}
|
|
if (expr.parent.kind === 299 /* PropertyAssignment */) {
|
|
const node2 = cast(expr.parent.parent, isObjectLiteralExpression);
|
|
const typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node2) || errorType;
|
|
const propertyIndex = indexOfNode(node2.properties, expr.parent);
|
|
return checkObjectLiteralDestructuringPropertyAssignment(node2, typeOfParentObjectLiteral, propertyIndex);
|
|
}
|
|
const node = cast(expr.parent, isArrayLiteralExpression);
|
|
const typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType;
|
|
const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */, typeOfArrayLiteral, undefinedType, expr.parent) || errorType;
|
|
return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType);
|
|
}
|
|
function getPropertySymbolOfDestructuringAssignment(location) {
|
|
const typeOfObjectLiteral = getTypeOfAssignmentPattern(cast(location.parent.parent, isAssignmentPattern));
|
|
return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.escapedText);
|
|
}
|
|
function getRegularTypeOfExpression(expr) {
|
|
if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
|
|
expr = expr.parent;
|
|
}
|
|
return getRegularTypeOfLiteralType(getTypeOfExpression(expr));
|
|
}
|
|
function getParentTypeOfClassElement(node) {
|
|
const classSymbol = getSymbolOfNode(node.parent);
|
|
return isStatic(node) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
|
|
}
|
|
function getClassElementPropertyKeyType(element) {
|
|
const name = element.name;
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return getStringLiteralType(idText(name));
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return getStringLiteralType(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
const nameType = checkComputedPropertyName(name);
|
|
return isTypeAssignableToKind(nameType, 12288 /* ESSymbolLike */) ? nameType : stringType;
|
|
default:
|
|
return Debug.fail("Unsupported property name.");
|
|
}
|
|
}
|
|
function getAugmentedPropertiesOfType(type) {
|
|
type = getApparentType(type);
|
|
const propsByName = createSymbolTable(getPropertiesOfType(type));
|
|
const functionType = getSignaturesOfType(type, 0 /* Call */).length ? globalCallableFunctionType : getSignaturesOfType(type, 1 /* Construct */).length ? globalNewableFunctionType : void 0;
|
|
if (functionType) {
|
|
forEach(getPropertiesOfType(functionType), (p) => {
|
|
if (!propsByName.has(p.escapedName)) {
|
|
propsByName.set(p.escapedName, p);
|
|
}
|
|
});
|
|
}
|
|
return getNamedMembers(propsByName);
|
|
}
|
|
function typeHasCallOrConstructSignatures2(type) {
|
|
return typeHasCallOrConstructSignatures(type, checker);
|
|
}
|
|
function getRootSymbols(symbol) {
|
|
const roots = getImmediateRootSymbols(symbol);
|
|
return roots ? flatMap(roots, getRootSymbols) : [symbol];
|
|
}
|
|
function getImmediateRootSymbols(symbol) {
|
|
if (getCheckFlags(symbol) & 6 /* Synthetic */) {
|
|
return mapDefined(getSymbolLinks(symbol).containingType.types, (type) => getPropertyOfType(type, symbol.escapedName));
|
|
} else if (symbol.flags & 33554432 /* Transient */) {
|
|
const { leftSpread, rightSpread, syntheticOrigin } = symbol;
|
|
return leftSpread ? [leftSpread, rightSpread] : syntheticOrigin ? [syntheticOrigin] : singleElementArray(tryGetTarget(symbol));
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetTarget(symbol) {
|
|
let target;
|
|
let next = symbol;
|
|
while (next = getSymbolLinks(next).target) {
|
|
target = next;
|
|
}
|
|
return target;
|
|
}
|
|
function isArgumentsLocalBinding(nodeIn) {
|
|
if (isGeneratedIdentifier(nodeIn))
|
|
return false;
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (!node)
|
|
return false;
|
|
const parent = node.parent;
|
|
if (!parent)
|
|
return false;
|
|
const isPropertyName2 = (isPropertyAccessExpression(parent) || isPropertyAssignment(parent)) && parent.name === node;
|
|
return !isPropertyName2 && getReferencedValueSymbol(node) === argumentsSymbol;
|
|
}
|
|
function moduleExportsSomeValue(moduleReferenceExpression) {
|
|
let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
|
|
if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
return true;
|
|
}
|
|
const hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
|
|
moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
|
|
const symbolLinks2 = getSymbolLinks(moduleSymbol);
|
|
if (symbolLinks2.exportsSomeValue === void 0) {
|
|
symbolLinks2.exportsSomeValue = hasExportAssignment ? !!(moduleSymbol.flags & 111551 /* Value */) : forEachEntry(getExportsOfModule(moduleSymbol), isValue);
|
|
}
|
|
return symbolLinks2.exportsSomeValue;
|
|
function isValue(s) {
|
|
s = resolveSymbol(s);
|
|
return s && !!(getAllSymbolFlags(s) & 111551 /* Value */);
|
|
}
|
|
}
|
|
function isNameOfModuleOrEnumDeclaration(node) {
|
|
return isModuleOrEnumDeclaration(node.parent) && node === node.parent.name;
|
|
}
|
|
function getReferencedExportContainer(nodeIn, prefixLocals) {
|
|
var _a2;
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
let symbol = getReferencedValueSymbol(node, isNameOfModuleOrEnumDeclaration(node));
|
|
if (symbol) {
|
|
if (symbol.flags & 1048576 /* ExportValue */) {
|
|
const exportSymbol = getMergedSymbol(symbol.exportSymbol);
|
|
if (!prefixLocals && exportSymbol.flags & 944 /* ExportHasLocal */ && !(exportSymbol.flags & 3 /* Variable */)) {
|
|
return void 0;
|
|
}
|
|
symbol = exportSymbol;
|
|
}
|
|
const parentSymbol = getParentOfSymbol(symbol);
|
|
if (parentSymbol) {
|
|
if (parentSymbol.flags & 512 /* ValueModule */ && ((_a2 = parentSymbol.valueDeclaration) == null ? void 0 : _a2.kind) === 308 /* SourceFile */) {
|
|
const symbolFile = parentSymbol.valueDeclaration;
|
|
const referenceFile = getSourceFileOfNode(node);
|
|
const symbolIsUmdExport = symbolFile !== referenceFile;
|
|
return symbolIsUmdExport ? void 0 : symbolFile;
|
|
}
|
|
return findAncestor(node.parent, (n) => isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getReferencedImportDeclaration(nodeIn) {
|
|
if (nodeIn.generatedImportReference) {
|
|
return nodeIn.generatedImportReference;
|
|
}
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
const symbol = getReferencedValueOrAliasSymbol(node);
|
|
if (isNonLocalAlias(symbol, 111551 /* Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */)) {
|
|
return getDeclarationOfAliasSymbol(symbol);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isSymbolOfDestructuredElementOfCatchBinding(symbol) {
|
|
return symbol.valueDeclaration && isBindingElement(symbol.valueDeclaration) && walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isSymbolOfDeclarationWithCollidingName(symbol) {
|
|
if (symbol.flags & 418 /* BlockScoped */ && symbol.valueDeclaration && !isSourceFile(symbol.valueDeclaration)) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.isDeclarationWithCollidingName === void 0) {
|
|
const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
|
|
if (isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) {
|
|
const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
|
|
if (resolveName(container.parent, symbol.escapedName, 111551 /* Value */, void 0, void 0, false)) {
|
|
links.isDeclarationWithCollidingName = true;
|
|
} else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
|
|
const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
|
|
const inLoopInitializer = isIterationStatement(container, false);
|
|
const inLoopBodyBlock = container.kind === 238 /* Block */ && isIterationStatement(container.parent, false);
|
|
links.isDeclarationWithCollidingName = !isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || !inLoopInitializer && !inLoopBodyBlock);
|
|
} else {
|
|
links.isDeclarationWithCollidingName = false;
|
|
}
|
|
}
|
|
}
|
|
return links.isDeclarationWithCollidingName;
|
|
}
|
|
return false;
|
|
}
|
|
function getReferencedDeclarationWithCollidingName(nodeIn) {
|
|
if (!isGeneratedIdentifier(nodeIn)) {
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
const symbol = getReferencedValueSymbol(node);
|
|
if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) {
|
|
return symbol.valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isDeclarationWithCollidingName(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isDeclaration);
|
|
if (node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol) {
|
|
return isSymbolOfDeclarationWithCollidingName(symbol);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isValueAliasDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return isAliasResolvedToValue(getSymbolOfNode(node));
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
const symbol = getSymbolOfNode(node);
|
|
return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
|
|
case 275 /* ExportDeclaration */:
|
|
const exportClause = node.exportClause;
|
|
return !!exportClause && (isNamespaceExport(exportClause) || some(exportClause.elements, isValueAliasDeclaration));
|
|
case 274 /* ExportAssignment */:
|
|
return node.expression && node.expression.kind === 79 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTopLevelValueImportEqualsWithEntityName(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isImportEqualsDeclaration);
|
|
if (node === void 0 || node.parent.kind !== 308 /* SourceFile */ || !isInternalModuleImportEqualsDeclaration(node)) {
|
|
return false;
|
|
}
|
|
const isValue = isAliasResolvedToValue(getSymbolOfNode(node));
|
|
return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
|
|
}
|
|
function isAliasResolvedToValue(symbol) {
|
|
var _a2;
|
|
if (!symbol) {
|
|
return false;
|
|
}
|
|
const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
|
|
if (target === unknownSymbol) {
|
|
return true;
|
|
}
|
|
return !!(((_a2 = getAllSymbolFlags(target)) != null ? _a2 : -1) & 111551 /* Value */) && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
|
|
}
|
|
function isConstEnumOrConstEnumOnlyModule(s) {
|
|
return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
|
|
}
|
|
function isReferencedAliasDeclaration(node, checkChildren) {
|
|
if (isAliasSymbolDeclaration(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const links = symbol && getSymbolLinks(symbol);
|
|
if (links == null ? void 0 : links.referenced) {
|
|
return true;
|
|
}
|
|
const target = getSymbolLinks(symbol).aliasTarget;
|
|
if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getAllSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
|
|
return true;
|
|
}
|
|
}
|
|
if (checkChildren) {
|
|
return !!forEachChild(node, (node2) => isReferencedAliasDeclaration(node2, checkChildren));
|
|
}
|
|
return false;
|
|
}
|
|
function isImplementationOfOverload(node) {
|
|
if (nodeIsPresent(node.body)) {
|
|
if (isGetAccessor(node) || isSetAccessor(node))
|
|
return false;
|
|
const symbol = getSymbolOfNode(node);
|
|
const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
|
|
return signaturesOfSymbol.length > 1 || signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
|
|
}
|
|
return false;
|
|
}
|
|
function isRequiredInitializedParameter(parameter) {
|
|
return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isOptionalUninitializedParameterProperty(parameter) {
|
|
return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isExpandoFunctionDeclaration(node) {
|
|
const declaration = getParseTreeNode(node, isFunctionDeclaration);
|
|
if (!declaration) {
|
|
return false;
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
if (!symbol || !(symbol.flags & 16 /* Function */)) {
|
|
return false;
|
|
}
|
|
return !!forEachEntry(getExportsOfSymbol(symbol), (p) => p.flags & 111551 /* Value */ && p.valueDeclaration && isPropertyAccessExpression(p.valueDeclaration));
|
|
}
|
|
function getPropertiesOfContainerFunction(node) {
|
|
const declaration = getParseTreeNode(node, isFunctionDeclaration);
|
|
if (!declaration) {
|
|
return emptyArray;
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || emptyArray;
|
|
}
|
|
function getNodeCheckFlags(node) {
|
|
var _a2;
|
|
const nodeId = node.id || 0;
|
|
if (nodeId < 0 || nodeId >= nodeLinks.length)
|
|
return 0;
|
|
return ((_a2 = nodeLinks[nodeId]) == null ? void 0 : _a2.flags) || 0;
|
|
}
|
|
function getEnumMemberValue(node) {
|
|
computeEnumMemberValues(node.parent);
|
|
return getNodeLinks(node).enumMemberValue;
|
|
}
|
|
function canHaveConstantValue(node) {
|
|
switch (node.kind) {
|
|
case 302 /* EnumMember */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getConstantValue2(node) {
|
|
if (node.kind === 302 /* EnumMember */) {
|
|
return getEnumMemberValue(node);
|
|
}
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol && symbol.flags & 8 /* EnumMember */) {
|
|
const member = symbol.valueDeclaration;
|
|
if (isEnumConst(member.parent)) {
|
|
return getEnumMemberValue(member);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isFunctionType(type) {
|
|
return !!(type.flags & 524288 /* Object */) && getSignaturesOfType(type, 0 /* Call */).length > 0;
|
|
}
|
|
function getTypeReferenceSerializationKind(typeNameIn, location) {
|
|
var _a2, _b;
|
|
const typeName = getParseTreeNode(typeNameIn, isEntityName);
|
|
if (!typeName)
|
|
return 0 /* Unknown */;
|
|
if (location) {
|
|
location = getParseTreeNode(location);
|
|
if (!location)
|
|
return 0 /* Unknown */;
|
|
}
|
|
let isTypeOnly = false;
|
|
if (isQualifiedName(typeName)) {
|
|
const rootValueSymbol = resolveEntityName(getFirstIdentifier(typeName), 111551 /* Value */, true, true, location);
|
|
isTypeOnly = !!((_a2 = rootValueSymbol == null ? void 0 : rootValueSymbol.declarations) == null ? void 0 : _a2.every(isTypeOnlyImportOrExportDeclaration));
|
|
}
|
|
const valueSymbol = resolveEntityName(typeName, 111551 /* Value */, true, true, location);
|
|
const resolvedSymbol = valueSymbol && valueSymbol.flags & 2097152 /* Alias */ ? resolveAlias(valueSymbol) : valueSymbol;
|
|
isTypeOnly || (isTypeOnly = !!((_b = valueSymbol == null ? void 0 : valueSymbol.declarations) == null ? void 0 : _b.every(isTypeOnlyImportOrExportDeclaration)));
|
|
const typeSymbol = resolveEntityName(typeName, 788968 /* Type */, true, false, location);
|
|
if (resolvedSymbol && resolvedSymbol === typeSymbol) {
|
|
const globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
|
|
if (globalPromiseSymbol && resolvedSymbol === globalPromiseSymbol) {
|
|
return 9 /* Promise */;
|
|
}
|
|
const constructorType = getTypeOfSymbol(resolvedSymbol);
|
|
if (constructorType && isConstructorType(constructorType)) {
|
|
return isTypeOnly ? 10 /* TypeWithCallSignature */ : 1 /* TypeWithConstructSignatureAndValue */;
|
|
}
|
|
}
|
|
if (!typeSymbol) {
|
|
return isTypeOnly ? 11 /* ObjectType */ : 0 /* Unknown */;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(typeSymbol);
|
|
if (isErrorType(type)) {
|
|
return isTypeOnly ? 11 /* ObjectType */ : 0 /* Unknown */;
|
|
} else if (type.flags & 3 /* AnyOrUnknown */) {
|
|
return 11 /* ObjectType */;
|
|
} else if (isTypeAssignableToKind(type, 16384 /* Void */ | 98304 /* Nullable */ | 131072 /* Never */)) {
|
|
return 2 /* VoidNullableOrNeverType */;
|
|
} else if (isTypeAssignableToKind(type, 528 /* BooleanLike */)) {
|
|
return 6 /* BooleanType */;
|
|
} else if (isTypeAssignableToKind(type, 296 /* NumberLike */)) {
|
|
return 3 /* NumberLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 2112 /* BigIntLike */)) {
|
|
return 4 /* BigIntLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 402653316 /* StringLike */)) {
|
|
return 5 /* StringLikeType */;
|
|
} else if (isTupleType(type)) {
|
|
return 7 /* ArrayLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 12288 /* ESSymbolLike */)) {
|
|
return 8 /* ESSymbolType */;
|
|
} else if (isFunctionType(type)) {
|
|
return 10 /* TypeWithCallSignature */;
|
|
} else if (isArrayType(type)) {
|
|
return 7 /* ArrayLikeType */;
|
|
} else {
|
|
return 11 /* ObjectType */;
|
|
}
|
|
}
|
|
function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
|
|
const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
|
|
if (!declaration) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
let type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol) {
|
|
flags |= 1048576 /* AllowUniqueESSymbolType */;
|
|
}
|
|
if (addUndefined) {
|
|
type = getOptionalType(type);
|
|
}
|
|
return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
|
|
const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
|
|
if (!signatureDeclaration) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const signature = getSignatureFromDeclaration(signatureDeclaration);
|
|
return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
|
|
const expr = getParseTreeNode(exprIn, isExpression);
|
|
if (!expr) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const type = getWidenedType(getRegularTypeOfExpression(expr));
|
|
return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function hasGlobalName(name) {
|
|
return globals.has(escapeLeadingUnderscores(name));
|
|
}
|
|
function getReferencedValueSymbol(reference, startInDeclarationContainer) {
|
|
const resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
|
|
if (resolvedSymbol) {
|
|
return resolvedSymbol;
|
|
}
|
|
let location = reference;
|
|
if (startInDeclarationContainer) {
|
|
const parent = reference.parent;
|
|
if (isDeclaration(parent) && reference === parent.name) {
|
|
location = getDeclarationContainer(parent);
|
|
}
|
|
}
|
|
return resolveName(location, reference.escapedText, 111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */, void 0, void 0, true);
|
|
}
|
|
function getReferencedValueOrAliasSymbol(reference) {
|
|
const resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
|
|
if (resolvedSymbol && resolvedSymbol !== unknownSymbol) {
|
|
return resolvedSymbol;
|
|
}
|
|
return resolveName(
|
|
reference,
|
|
reference.escapedText,
|
|
111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */,
|
|
void 0,
|
|
void 0,
|
|
true,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
function getReferencedValueDeclaration(referenceIn) {
|
|
if (!isGeneratedIdentifier(referenceIn)) {
|
|
const reference = getParseTreeNode(referenceIn, isIdentifier);
|
|
if (reference) {
|
|
const symbol = getReferencedValueSymbol(reference);
|
|
if (symbol) {
|
|
return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isLiteralConstDeclaration(node) {
|
|
if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node)) {
|
|
return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node)));
|
|
}
|
|
return false;
|
|
}
|
|
function literalTypeToNode(type, enclosing, tracker) {
|
|
const enumResult = type.flags & 1024 /* EnumLiteral */ ? nodeBuilder.symbolToExpression(type.symbol, 111551 /* Value */, enclosing, void 0, tracker) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
|
|
if (enumResult)
|
|
return enumResult;
|
|
const literalValue = type.value;
|
|
return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
|
|
}
|
|
function createLiteralConstValue(node, tracker) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(node));
|
|
return literalTypeToNode(type, node, tracker);
|
|
}
|
|
function getJsxFactoryEntity(location) {
|
|
return location ? (getJsxNamespace(location), getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity) : _jsxFactoryEntity;
|
|
}
|
|
function getJsxFragmentFactoryEntity(location) {
|
|
if (location) {
|
|
const file = getSourceFileOfNode(location);
|
|
if (file) {
|
|
if (file.localJsxFragmentFactory) {
|
|
return file.localJsxFragmentFactory;
|
|
}
|
|
const jsxFragPragmas = file.pragmas.get("jsxfrag");
|
|
const jsxFragPragma = isArray(jsxFragPragmas) ? jsxFragPragmas[0] : jsxFragPragmas;
|
|
if (jsxFragPragma) {
|
|
file.localJsxFragmentFactory = parseIsolatedEntityName(jsxFragPragma.arguments.factory, languageVersion);
|
|
return file.localJsxFragmentFactory;
|
|
}
|
|
}
|
|
}
|
|
if (compilerOptions.jsxFragmentFactory) {
|
|
return parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
|
|
}
|
|
}
|
|
function createResolver() {
|
|
const resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
|
|
let fileToDirective;
|
|
if (resolvedTypeReferenceDirectives) {
|
|
fileToDirective = /* @__PURE__ */ new Map();
|
|
resolvedTypeReferenceDirectives.forEach((resolvedDirective, key, mode) => {
|
|
if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
|
|
return;
|
|
}
|
|
const file = host.getSourceFile(resolvedDirective.resolvedFileName);
|
|
if (file) {
|
|
addReferencedFilesToTypeDirective(file, key, mode);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
getReferencedExportContainer,
|
|
getReferencedImportDeclaration,
|
|
getReferencedDeclarationWithCollidingName,
|
|
isDeclarationWithCollidingName,
|
|
isValueAliasDeclaration: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? isValueAliasDeclaration(node) : true;
|
|
},
|
|
hasGlobalName,
|
|
isReferencedAliasDeclaration: (nodeIn, checkChildren) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
|
|
},
|
|
getNodeCheckFlags: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getNodeCheckFlags(node) : 0;
|
|
},
|
|
isTopLevelValueImportEqualsWithEntityName,
|
|
isDeclarationVisible,
|
|
isImplementationOfOverload,
|
|
isRequiredInitializedParameter,
|
|
isOptionalUninitializedParameterProperty,
|
|
isExpandoFunctionDeclaration,
|
|
getPropertiesOfContainerFunction,
|
|
createTypeOfDeclaration,
|
|
createReturnTypeOfSignatureDeclaration,
|
|
createTypeOfExpression,
|
|
createLiteralConstValue,
|
|
isSymbolAccessible,
|
|
isEntityNameVisible,
|
|
getConstantValue: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, canHaveConstantValue);
|
|
return node ? getConstantValue2(node) : void 0;
|
|
},
|
|
collectLinkedAliases,
|
|
getReferencedValueDeclaration,
|
|
getTypeReferenceSerializationKind,
|
|
isOptionalParameter,
|
|
moduleExportsSomeValue,
|
|
isArgumentsLocalBinding,
|
|
getExternalModuleFileFromDeclaration: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, hasPossibleExternalModuleReference);
|
|
return node && getExternalModuleFileFromDeclaration(node);
|
|
},
|
|
getTypeReferenceDirectivesForEntityName,
|
|
getTypeReferenceDirectivesForSymbol,
|
|
isLiteralConstDeclaration,
|
|
isLateBound: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isDeclaration);
|
|
const symbol = node && getSymbolOfNode(node);
|
|
return !!(symbol && getCheckFlags(symbol) & 4096 /* Late */);
|
|
},
|
|
getJsxFactoryEntity,
|
|
getJsxFragmentFactoryEntity,
|
|
getAllAccessorDeclarations(accessor) {
|
|
accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
|
|
const otherKind = accessor.kind === 175 /* SetAccessor */ ? 174 /* GetAccessor */ : 175 /* SetAccessor */;
|
|
const otherAccessor = getDeclarationOfKind(getSymbolOfNode(accessor), otherKind);
|
|
const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
|
|
const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
|
|
const setAccessor = accessor.kind === 175 /* SetAccessor */ ? accessor : otherAccessor;
|
|
const getAccessor = accessor.kind === 174 /* GetAccessor */ ? accessor : otherAccessor;
|
|
return {
|
|
firstAccessor,
|
|
secondAccessor,
|
|
setAccessor,
|
|
getAccessor
|
|
};
|
|
},
|
|
getSymbolOfExternalModuleSpecifier: (moduleName) => resolveExternalModuleNameWorker(moduleName, moduleName, void 0),
|
|
isBindingCapturedByNode: (node, decl) => {
|
|
const parseNode = getParseTreeNode(node);
|
|
const parseDecl = getParseTreeNode(decl);
|
|
return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
|
|
},
|
|
getDeclarationStatementsForSourceFile: (node, flags, tracker, bundled) => {
|
|
const n = getParseTreeNode(node);
|
|
Debug.assert(n && n.kind === 308 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
|
|
const 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
|
|
};
|
|
function isImportRequiredByAugmentation(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (!file.symbol)
|
|
return false;
|
|
const importTarget = getExternalModuleFileFromDeclaration(node);
|
|
if (!importTarget)
|
|
return false;
|
|
if (importTarget === file)
|
|
return false;
|
|
const exports = getExportsOfModule(file.symbol);
|
|
for (const s of arrayFrom(exports.values())) {
|
|
if (s.mergeId) {
|
|
const merged = getMergedSymbol(s);
|
|
if (merged.declarations) {
|
|
for (const d of merged.declarations) {
|
|
const declFile = getSourceFileOfNode(d);
|
|
if (declFile === importTarget) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInHeritageClause(node) {
|
|
return node.parent && node.parent.kind === 230 /* ExpressionWithTypeArguments */ && node.parent.parent && node.parent.parent.kind === 294 /* HeritageClause */;
|
|
}
|
|
function getTypeReferenceDirectivesForEntityName(node) {
|
|
if (!fileToDirective) {
|
|
return void 0;
|
|
}
|
|
let meaning;
|
|
if (node.parent.kind === 164 /* ComputedPropertyName */) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
} else {
|
|
meaning = 788968 /* Type */ | 1920 /* Namespace */;
|
|
if (node.kind === 79 /* Identifier */ && isInTypeQuery(node) || node.kind === 208 /* PropertyAccessExpression */ && !isInHeritageClause(node)) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
}
|
|
}
|
|
const symbol = resolveEntityName(node, meaning, true);
|
|
return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : void 0;
|
|
}
|
|
function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
|
|
if (!fileToDirective || !isSymbolFromTypeDeclarationFile(symbol)) {
|
|
return void 0;
|
|
}
|
|
let typeReferenceDirectives;
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.symbol && decl.symbol.flags & meaning) {
|
|
const file = getSourceFileOfNode(decl);
|
|
const typeReferenceDirective = fileToDirective.get(file.path);
|
|
if (typeReferenceDirective) {
|
|
(typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return typeReferenceDirectives;
|
|
}
|
|
function isSymbolFromTypeDeclarationFile(symbol) {
|
|
if (!symbol.declarations) {
|
|
return false;
|
|
}
|
|
let current = symbol;
|
|
while (true) {
|
|
const parent = getParentOfSymbol(current);
|
|
if (parent) {
|
|
current = parent;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (current.valueDeclaration && current.valueDeclaration.kind === 308 /* SourceFile */ && current.flags & 512 /* ValueModule */) {
|
|
return false;
|
|
}
|
|
for (const decl of symbol.declarations) {
|
|
const file = 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 (const { fileName, resolutionMode } of file.referencedFiles) {
|
|
const resolvedFile = resolveTripleslashReference(fileName, file.fileName);
|
|
const referencedFile = host.getSourceFile(resolvedFile);
|
|
if (referencedFile) {
|
|
addReferencedFilesToTypeDirective(referencedFile, key, resolutionMode || file.impliedNodeFormat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getExternalModuleFileFromDeclaration(declaration) {
|
|
const specifier = declaration.kind === 264 /* ModuleDeclaration */ ? tryCast(declaration.name, isStringLiteral) : getExternalModuleName(declaration);
|
|
const moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, void 0);
|
|
if (!moduleSymbol) {
|
|
return void 0;
|
|
}
|
|
return getDeclarationOfKind(moduleSymbol, 308 /* SourceFile */);
|
|
}
|
|
function initializeTypeChecker() {
|
|
for (const file of host.getSourceFiles()) {
|
|
bindSourceFile(file, compilerOptions);
|
|
}
|
|
amalgamatedDuplicates = /* @__PURE__ */ new Map();
|
|
let augmentations;
|
|
for (const file of host.getSourceFiles()) {
|
|
if (file.redirectInfo) {
|
|
continue;
|
|
}
|
|
if (!isExternalOrCommonJsModule(file)) {
|
|
const fileGlobalThisSymbol = file.locals.get("globalThis");
|
|
if (fileGlobalThisSymbol == null ? void 0 : fileGlobalThisSymbol.declarations) {
|
|
for (const declaration of fileGlobalThisSymbol.declarations) {
|
|
diagnostics.add(createDiagnosticForNode(declaration, 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 = concatenate(patternAmbientModules, file.patternAmbientModules);
|
|
}
|
|
if (file.moduleAugmentations.length) {
|
|
(augmentations || (augmentations = [])).push(file.moduleAugmentations);
|
|
}
|
|
if (file.symbol && file.symbol.globalExports) {
|
|
const source = file.symbol.globalExports;
|
|
source.forEach((sourceSymbol, id) => {
|
|
if (!globals.has(id)) {
|
|
globals.set(id, sourceSymbol);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (augmentations) {
|
|
for (const list of augmentations) {
|
|
for (const augmentation of list) {
|
|
if (!isGlobalScopeAugmentation(augmentation.parent))
|
|
continue;
|
|
mergeModuleAugmentation(augmentation);
|
|
}
|
|
}
|
|
}
|
|
addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
|
|
getSymbolLinks(undefinedSymbol).type = undefinedWideningType;
|
|
getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments", 0, true);
|
|
getSymbolLinks(unknownSymbol).type = errorType;
|
|
getSymbolLinks(globalThisSymbol).type = createObjectType(16 /* Anonymous */, globalThisSymbol);
|
|
globalArrayType = getGlobalType("Array", 1, true);
|
|
globalObjectType = getGlobalType("Object", 0, true);
|
|
globalFunctionType = getGlobalType("Function", 0, true);
|
|
globalCallableFunctionType = strictBindCallApply && getGlobalType("CallableFunction", 0, true) || globalFunctionType;
|
|
globalNewableFunctionType = strictBindCallApply && getGlobalType("NewableFunction", 0, true) || globalFunctionType;
|
|
globalStringType = getGlobalType("String", 0, true);
|
|
globalNumberType = getGlobalType("Number", 0, true);
|
|
globalBooleanType = getGlobalType("Boolean", 0, true);
|
|
globalRegExpType = getGlobalType("RegExp", 0, true);
|
|
anyArrayType = createArrayType(anyType);
|
|
autoArrayType = createArrayType(autoType);
|
|
if (autoArrayType === emptyObjectType) {
|
|
autoArrayType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType;
|
|
anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
|
|
globalThisType = getGlobalTypeOrUndefined("ThisType", 1);
|
|
if (augmentations) {
|
|
for (const list of augmentations) {
|
|
for (const augmentation of list) {
|
|
if (isGlobalScopeAugmentation(augmentation.parent))
|
|
continue;
|
|
mergeModuleAugmentation(augmentation);
|
|
}
|
|
}
|
|
}
|
|
amalgamatedDuplicates.forEach(({ firstFile, secondFile, conflictingSymbols }) => {
|
|
if (conflictingSymbols.size < 8) {
|
|
conflictingSymbols.forEach(({ isBlockScoped, firstFileLocations, secondFileLocations }, symbolName2) => {
|
|
const message = isBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
for (const node of firstFileLocations) {
|
|
addDuplicateDeclarationError(node, message, symbolName2, secondFileLocations);
|
|
}
|
|
for (const node of secondFileLocations) {
|
|
addDuplicateDeclarationError(node, message, symbolName2, firstFileLocations);
|
|
}
|
|
});
|
|
} else {
|
|
const list = arrayFrom(conflictingSymbols.keys()).join(", ");
|
|
diagnostics.add(addRelatedInfo(
|
|
createDiagnosticForNode(firstFile, Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list),
|
|
createDiagnosticForNode(secondFile, Diagnostics.Conflicts_are_in_this_file)
|
|
));
|
|
diagnostics.add(addRelatedInfo(
|
|
createDiagnosticForNode(secondFile, Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list),
|
|
createDiagnosticForNode(firstFile, Diagnostics.Conflicts_are_in_this_file)
|
|
));
|
|
}
|
|
});
|
|
amalgamatedDuplicates = void 0;
|
|
}
|
|
function checkExternalEmitHelpers(location, helpers) {
|
|
if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) {
|
|
const sourceFile = getSourceFileOfNode(location);
|
|
if (isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 16777216 /* Ambient */)) {
|
|
const helpersModule = resolveHelpersModule(sourceFile, location);
|
|
if (helpersModule !== unknownSymbol) {
|
|
const uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
|
|
for (let helper = 1 /* FirstEmitHelper */; helper <= 4194304 /* LastEmitHelper */; helper <<= 1) {
|
|
if (uncheckedHelpers & helper) {
|
|
const name = getHelperName(helper);
|
|
const symbol = getSymbol(helpersModule.exports, escapeLeadingUnderscores(name), 111551 /* Value */);
|
|
if (!symbol) {
|
|
error(location, Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name);
|
|
} else if (helper & 524288 /* ClassPrivateFieldGet */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 3)) {
|
|
error(location, 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, externalHelpersModuleNameText, name, 4);
|
|
}
|
|
} else if (helper & 1048576 /* ClassPrivateFieldSet */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 4)) {
|
|
error(location, 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, externalHelpersModuleNameText, name, 5);
|
|
}
|
|
} else if (helper & 1024 /* SpreadArray */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 2)) {
|
|
error(location, 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, externalHelpersModuleNameText, name, 3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
requestedExternalEmitHelpers |= helpers;
|
|
}
|
|
}
|
|
}
|
|
function getHelperName(helper) {
|
|
switch (helper) {
|
|
case 1 /* Extends */:
|
|
return "__extends";
|
|
case 2 /* Assign */:
|
|
return "__assign";
|
|
case 4 /* Rest */:
|
|
return "__rest";
|
|
case 8 /* Decorate */:
|
|
return "__decorate";
|
|
case 16 /* Metadata */:
|
|
return "__metadata";
|
|
case 32 /* Param */:
|
|
return "__param";
|
|
case 64 /* Awaiter */:
|
|
return "__awaiter";
|
|
case 128 /* Generator */:
|
|
return "__generator";
|
|
case 256 /* Values */:
|
|
return "__values";
|
|
case 512 /* Read */:
|
|
return "__read";
|
|
case 1024 /* SpreadArray */:
|
|
return "__spreadArray";
|
|
case 2048 /* Await */:
|
|
return "__await";
|
|
case 4096 /* AsyncGenerator */:
|
|
return "__asyncGenerator";
|
|
case 8192 /* AsyncDelegator */:
|
|
return "__asyncDelegator";
|
|
case 16384 /* AsyncValues */:
|
|
return "__asyncValues";
|
|
case 32768 /* ExportStar */:
|
|
return "__exportStar";
|
|
case 65536 /* ImportStar */:
|
|
return "__importStar";
|
|
case 131072 /* ImportDefault */:
|
|
return "__importDefault";
|
|
case 262144 /* MakeTemplateObject */:
|
|
return "__makeTemplateObject";
|
|
case 524288 /* ClassPrivateFieldGet */:
|
|
return "__classPrivateFieldGet";
|
|
case 1048576 /* ClassPrivateFieldSet */:
|
|
return "__classPrivateFieldSet";
|
|
case 2097152 /* ClassPrivateFieldIn */:
|
|
return "__classPrivateFieldIn";
|
|
case 4194304 /* CreateBinding */:
|
|
return "__createBinding";
|
|
default:
|
|
return Debug.fail("Unrecognized helper");
|
|
}
|
|
}
|
|
function resolveHelpersModule(node, errorNode) {
|
|
if (!externalHelpersModule) {
|
|
externalHelpersModule = resolveExternalModule(node, externalHelpersModuleNameText, Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol;
|
|
}
|
|
return externalHelpersModule;
|
|
}
|
|
function checkGrammarDecoratorsAndModifiers(node) {
|
|
return checkGrammarDecorators(node) || checkGrammarModifiers(node);
|
|
}
|
|
function checkGrammarDecorators(node) {
|
|
if (canHaveIllegalDecorators(node) && some(node.illegalDecorators)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
|
|
}
|
|
if (!canHaveDecorators(node) || !hasDecorators(node)) {
|
|
return false;
|
|
}
|
|
if (!nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
|
|
if (node.kind === 171 /* MethodDeclaration */ && !nodeIsPresent(node.body)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
|
|
} else {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
|
|
}
|
|
} else if (node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */) {
|
|
const accessors = getAllAccessorDeclarations(node.parent.members, node);
|
|
if (hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarModifiers(node) {
|
|
const quickResult = reportObviousModifierErrors(node);
|
|
if (quickResult !== void 0) {
|
|
return quickResult;
|
|
}
|
|
let lastStatic, lastDeclare, lastAsync, lastOverride;
|
|
let flags = 0 /* None */;
|
|
for (const modifier of node.modifiers) {
|
|
if (isDecorator(modifier))
|
|
continue;
|
|
if (modifier.kind !== 146 /* ReadonlyKeyword */) {
|
|
if (node.kind === 168 /* PropertySignature */ || node.kind === 170 /* MethodSignature */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_type_member, tokenToString(modifier.kind));
|
|
}
|
|
if (node.kind === 178 /* IndexSignature */ && (modifier.kind !== 124 /* StaticKeyword */ || !isClassLike(node.parent))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_index_signature, tokenToString(modifier.kind));
|
|
}
|
|
}
|
|
if (modifier.kind !== 101 /* InKeyword */ && modifier.kind !== 145 /* OutKeyword */) {
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_type_parameter, tokenToString(modifier.kind));
|
|
}
|
|
}
|
|
switch (modifier.kind) {
|
|
case 85 /* ConstKeyword */:
|
|
if (node.kind !== 263 /* EnumDeclaration */) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_class_member_cannot_have_the_0_keyword, tokenToString(85 /* ConstKeyword */));
|
|
}
|
|
break;
|
|
case 161 /* OverrideKeyword */:
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "override");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "override", "declare");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "async");
|
|
}
|
|
flags |= 16384 /* Override */;
|
|
lastOverride = modifier;
|
|
break;
|
|
case 123 /* PublicKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
const text = visibilityToString(modifierToFlag(modifier.kind));
|
|
if (flags & 28 /* AccessibilityModifier */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "override");
|
|
} else if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
|
|
} else if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
|
|
} else if (flags & 256 /* Abstract */) {
|
|
if (modifier.kind === 121 /* PrivateKeyword */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
|
|
} else {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract");
|
|
}
|
|
} else if (isPrivateIdentifierClassElementDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
|
|
}
|
|
flags |= modifierToFlag(modifier.kind);
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor");
|
|
} else if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
|
|
} else if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "override");
|
|
}
|
|
flags |= 32 /* Static */;
|
|
lastStatic = modifier;
|
|
break;
|
|
case 127 /* AccessorKeyword */:
|
|
if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "accessor");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare");
|
|
} else if (node.kind !== 169 /* PropertyDeclaration */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration);
|
|
}
|
|
flags |= 128 /* Accessor */;
|
|
break;
|
|
case 146 /* ReadonlyKeyword */:
|
|
if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "readonly");
|
|
} else if (node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 168 /* PropertySignature */ && node.kind !== 178 /* IndexSignature */ && node.kind !== 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
|
|
}
|
|
flags |= 64 /* Readonly */;
|
|
break;
|
|
case 93 /* ExportKeyword */:
|
|
if (flags & 1 /* Export */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
|
|
} else if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
|
|
} else if (isClassLike(node.parent)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
|
|
}
|
|
flags |= 1 /* Export */;
|
|
break;
|
|
case 88 /* DefaultKeyword */:
|
|
const container = node.parent.kind === 308 /* SourceFile */ ? node.parent : node.parent.parent;
|
|
if (container.kind === 264 /* ModuleDeclaration */ && !isAmbientModule(container)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
|
|
} else if (!(flags & 1 /* Export */)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "default");
|
|
}
|
|
flags |= 1024 /* Default */;
|
|
break;
|
|
case 136 /* DeclareKeyword */:
|
|
if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "override");
|
|
} else if (isClassLike(node.parent) && !isPropertyDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
|
|
} else if (node.parent.flags & 16777216 /* Ambient */ && node.parent.kind === 265 /* ModuleBlock */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
|
|
} else if (isPrivateIdentifierClassElementDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
|
|
}
|
|
flags |= 2 /* Ambient */;
|
|
lastDeclare = modifier;
|
|
break;
|
|
case 126 /* AbstractKeyword */:
|
|
if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "abstract");
|
|
}
|
|
if (node.kind !== 260 /* ClassDeclaration */ && node.kind !== 182 /* ConstructorType */) {
|
|
if (node.kind !== 171 /* MethodDeclaration */ && node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 174 /* GetAccessor */ && node.kind !== 175 /* SetAccessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
|
|
}
|
|
if (!(node.parent.kind === 260 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
|
|
}
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
|
|
}
|
|
if (flags & 8 /* Private */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
|
|
}
|
|
if (flags & 512 /* Async */ && lastAsync) {
|
|
return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
|
|
}
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override");
|
|
}
|
|
if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor");
|
|
}
|
|
}
|
|
if (isNamedDeclaration(node) && node.name.kind === 80 /* PrivateIdentifier */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
|
|
}
|
|
flags |= 256 /* Abstract */;
|
|
break;
|
|
case 132 /* AsyncKeyword */:
|
|
if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "async");
|
|
} else if (flags & 2 /* Ambient */ || node.parent.flags & 16777216 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
|
|
}
|
|
if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
|
|
}
|
|
flags |= 512 /* Async */;
|
|
lastAsync = modifier;
|
|
break;
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
const inOutFlag = modifier.kind === 101 /* InKeyword */ ? 32768 /* In */ : 65536 /* Out */;
|
|
const inOutText = modifier.kind === 101 /* InKeyword */ ? "in" : "out";
|
|
if (node.kind !== 165 /* TypeParameter */ || !(isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText);
|
|
}
|
|
if (flags & inOutFlag) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, inOutText);
|
|
}
|
|
if (inOutFlag & 32768 /* In */ && flags & 65536 /* Out */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "in", "out");
|
|
}
|
|
flags |= inOutFlag;
|
|
break;
|
|
}
|
|
}
|
|
if (node.kind === 173 /* Constructor */) {
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
|
|
}
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(lastOverride, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "override");
|
|
}
|
|
if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
|
|
}
|
|
return false;
|
|
} else if ((node.kind === 269 /* ImportDeclaration */ || node.kind === 268 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
|
|
} else if (node.kind === 166 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
|
|
} else if (node.kind === 166 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
|
|
}
|
|
if (flags & 512 /* Async */) {
|
|
return checkGrammarAsyncModifier(node, lastAsync);
|
|
}
|
|
return false;
|
|
}
|
|
function reportObviousModifierErrors(node) {
|
|
return !node.modifiers ? false : shouldReportBadModifier(node) ? grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here) : void 0;
|
|
}
|
|
function shouldReportBadModifier(node) {
|
|
switch (node.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 166 /* Parameter */:
|
|
case 165 /* TypeParameter */:
|
|
return false;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
case 181 /* FunctionType */:
|
|
case 279 /* MissingDeclaration */:
|
|
return true;
|
|
default:
|
|
if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return false;
|
|
}
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return nodeHasAnyModifiersExcept(node, 132 /* AsyncKeyword */);
|
|
case 260 /* ClassDeclaration */:
|
|
case 182 /* ConstructorType */:
|
|
return nodeHasAnyModifiersExcept(node, 126 /* AbstractKeyword */);
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
case 263 /* EnumDeclaration */:
|
|
return nodeHasAnyModifiersExcept(node, 85 /* ConstKeyword */);
|
|
default:
|
|
Debug.assertNever(node);
|
|
}
|
|
}
|
|
}
|
|
function nodeHasAnyModifiersExcept(node, allowedModifier) {
|
|
for (const modifier of node.modifiers) {
|
|
if (isDecorator(modifier))
|
|
continue;
|
|
return modifier.kind !== allowedModifier;
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarAsyncModifier(node, asyncModifier) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return false;
|
|
}
|
|
return grammarErrorOnNode(asyncModifier, Diagnostics._0_modifier_cannot_be_used_here, "async");
|
|
}
|
|
function checkGrammarForDisallowedTrailingComma(list, diag2 = Diagnostics.Trailing_comma_not_allowed) {
|
|
if (list && list.hasTrailingComma) {
|
|
return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag2);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarTypeParameterList(typeParameters, file) {
|
|
if (typeParameters && typeParameters.length === 0) {
|
|
const start = typeParameters.pos - "<".length;
|
|
const end = skipTrivia(file.text, typeParameters.end) + ">".length;
|
|
return grammarErrorAtPos(file, start, end - start, Diagnostics.Type_parameter_list_cannot_be_empty);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarParameterList(parameters) {
|
|
let seenOptionalParameter = false;
|
|
const parameterCount = parameters.length;
|
|
for (let i = 0; i < parameterCount; i++) {
|
|
const parameter = parameters[i];
|
|
if (parameter.dotDotDotToken) {
|
|
if (i !== parameterCount - 1) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
if (!(parameter.flags & 16777216 /* Ambient */)) {
|
|
checkGrammarForDisallowedTrailingComma(parameters, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_rest_parameter_cannot_be_optional);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
|
|
}
|
|
} else if (isOptionalParameter(parameter)) {
|
|
seenOptionalParameter = true;
|
|
if (parameter.questionToken && parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
|
|
}
|
|
} else if (seenOptionalParameter && !parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
|
|
}
|
|
}
|
|
}
|
|
function getNonSimpleParameters(parameters) {
|
|
return filter(parameters, (parameter) => !!parameter.initializer || isBindingPattern(parameter.name) || isRestParameter(parameter));
|
|
}
|
|
function checkGrammarForUseStrictSimpleParameterList(node) {
|
|
if (languageVersion >= 3 /* ES2016 */) {
|
|
const useStrictDirective = node.body && isBlock(node.body) && findUseStrictPrologue(node.body.statements);
|
|
if (useStrictDirective) {
|
|
const nonSimpleParameters = getNonSimpleParameters(node.parameters);
|
|
if (length(nonSimpleParameters)) {
|
|
forEach(nonSimpleParameters, (parameter) => {
|
|
addRelatedInfo(
|
|
error(parameter, Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive),
|
|
createDiagnosticForNode(useStrictDirective, Diagnostics.use_strict_directive_used_here)
|
|
);
|
|
});
|
|
const diagnostics2 = nonSimpleParameters.map((parameter, index) => index === 0 ? createDiagnosticForNode(parameter, Diagnostics.Non_simple_parameter_declared_here) : createDiagnosticForNode(parameter, Diagnostics.and_here));
|
|
addRelatedInfo(error(useStrictDirective, Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list), ...diagnostics2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarFunctionLikeDeclaration(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) || checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file) || isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node);
|
|
}
|
|
function checkGrammarClassLikeDeclaration(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file);
|
|
}
|
|
function checkGrammarArrowFunction(node, file) {
|
|
if (!isArrowFunction(node)) {
|
|
return false;
|
|
}
|
|
if (node.typeParameters && !(length(node.typeParameters) > 1 || node.typeParameters.hasTrailingComma || node.typeParameters[0].constraint)) {
|
|
if (file && fileExtensionIsOneOf(file.fileName, [".mts" /* Mts */, ".cts" /* Cts */])) {
|
|
grammarErrorOnNode(node.typeParameters[0], Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint);
|
|
}
|
|
}
|
|
const { equalsGreaterThanToken } = node;
|
|
const startLine = getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line;
|
|
const endLine = getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line;
|
|
return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, Diagnostics.Line_terminator_not_permitted_before_arrow);
|
|
}
|
|
function checkGrammarIndexSignatureParameters(node) {
|
|
const parameter = node.parameters[0];
|
|
if (node.parameters.length !== 1) {
|
|
if (parameter) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
|
|
} else {
|
|
return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
|
|
}
|
|
}
|
|
checkGrammarForDisallowedTrailingComma(node.parameters, Diagnostics.An_index_signature_cannot_have_a_trailing_comma);
|
|
if (parameter.dotDotDotToken) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
|
|
}
|
|
if (hasEffectiveModifiers(parameter)) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
|
|
}
|
|
if (!parameter.type) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
|
|
}
|
|
const type = getTypeFromTypeNode(parameter.type);
|
|
if (someType(type, (t) => !!(t.flags & 8576 /* StringOrNumberLiteralOrUnique */)) || isGenericType(type)) {
|
|
return grammarErrorOnNode(parameter.name, 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, Diagnostics.An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type);
|
|
}
|
|
if (!node.type) {
|
|
return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_a_type_annotation);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarIndexSignature(node) {
|
|
return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node);
|
|
}
|
|
function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) {
|
|
if (typeArguments && typeArguments.length === 0) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const start = typeArguments.pos - "<".length;
|
|
const end = skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
|
|
return grammarErrorAtPos(sourceFile, start, end - start, 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 /* OptionalChain */) {
|
|
return grammarErrorOnNode(node.template, Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarHeritageClause(node) {
|
|
const types = node.types;
|
|
if (checkGrammarForDisallowedTrailingComma(types)) {
|
|
return true;
|
|
}
|
|
if (types && types.length === 0) {
|
|
const listType = tokenToString(node.token);
|
|
return grammarErrorAtPos(node, types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType);
|
|
}
|
|
return some(types, checkGrammarExpressionWithTypeArguments);
|
|
}
|
|
function checkGrammarExpressionWithTypeArguments(node) {
|
|
if (isExpressionWithTypeArguments(node) && isImportKeyword(node.expression) && node.typeArguments) {
|
|
return grammarErrorOnNode(node, 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) {
|
|
let seenExtendsClause = false;
|
|
let seenImplementsClause = false;
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) {
|
|
for (const heritageClause of node.heritageClauses) {
|
|
if (heritageClause.token === 94 /* ExtendsKeyword */) {
|
|
if (seenExtendsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
|
|
}
|
|
if (seenImplementsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_must_precede_implements_clause);
|
|
}
|
|
if (heritageClause.types.length > 1) {
|
|
return grammarErrorOnFirstToken(heritageClause.types[1], Diagnostics.Classes_can_only_extend_a_single_class);
|
|
}
|
|
seenExtendsClause = true;
|
|
} else {
|
|
Debug.assert(heritageClause.token === 117 /* ImplementsKeyword */);
|
|
if (seenImplementsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.implements_clause_already_seen);
|
|
}
|
|
seenImplementsClause = true;
|
|
}
|
|
checkGrammarHeritageClause(heritageClause);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarInterfaceDeclaration(node) {
|
|
let seenExtendsClause = false;
|
|
if (node.heritageClauses) {
|
|
for (const heritageClause of node.heritageClauses) {
|
|
if (heritageClause.token === 94 /* ExtendsKeyword */) {
|
|
if (seenExtendsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
|
|
}
|
|
seenExtendsClause = true;
|
|
} else {
|
|
Debug.assert(heritageClause.token === 117 /* ImplementsKeyword */);
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.Interface_declaration_cannot_have_implements_clause);
|
|
}
|
|
checkGrammarHeritageClause(heritageClause);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarComputedPropertyName(node) {
|
|
if (node.kind !== 164 /* ComputedPropertyName */) {
|
|
return false;
|
|
}
|
|
const computedPropertyName = node;
|
|
if (computedPropertyName.expression.kind === 223 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 27 /* CommaToken */) {
|
|
return grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarForGenerator(node) {
|
|
if (node.asteriskToken) {
|
|
Debug.assert(
|
|
node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */ || node.kind === 171 /* MethodDeclaration */
|
|
);
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
|
|
}
|
|
if (!node.body) {
|
|
return grammarErrorOnNode(node.asteriskToken, 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) {
|
|
const seen = /* @__PURE__ */ new Map();
|
|
for (const prop of node.properties) {
|
|
if (prop.kind === 301 /* SpreadAssignment */) {
|
|
if (inDestructuring) {
|
|
const expression = skipParentheses(prop.expression);
|
|
if (isArrayLiteralExpression(expression) || isObjectLiteralExpression(expression)) {
|
|
return grammarErrorOnNode(prop.expression, Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
const name = prop.name;
|
|
if (name.kind === 164 /* ComputedPropertyName */) {
|
|
checkGrammarComputedPropertyName(name);
|
|
}
|
|
if (prop.kind === 300 /* ShorthandPropertyAssignment */ && !inDestructuring && prop.objectAssignmentInitializer) {
|
|
grammarErrorOnNode(prop.equalsToken, 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 /* PrivateIdentifier */) {
|
|
grammarErrorOnNode(name, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
if (canHaveModifiers(prop) && prop.modifiers) {
|
|
for (const mod of prop.modifiers) {
|
|
if (isModifier(mod) && (mod.kind !== 132 /* AsyncKeyword */ || prop.kind !== 171 /* MethodDeclaration */)) {
|
|
grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
|
|
}
|
|
}
|
|
} else if (canHaveIllegalModifiers(prop) && prop.modifiers) {
|
|
for (const mod of prop.modifiers) {
|
|
grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
|
|
}
|
|
}
|
|
let currentKind;
|
|
switch (prop.kind) {
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 299 /* PropertyAssignment */:
|
|
checkGrammarForInvalidExclamationToken(prop.exclamationToken, Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context);
|
|
checkGrammarForInvalidQuestionMark(prop.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
|
|
if (name.kind === 8 /* NumericLiteral */) {
|
|
checkGrammarNumericLiteral(name);
|
|
}
|
|
currentKind = 4 /* PropertyAssignment */;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
currentKind = 8 /* Method */;
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
currentKind = 1 /* GetAccessor */;
|
|
break;
|
|
case 175 /* SetAccessor */:
|
|
currentKind = 2 /* SetAccessor */;
|
|
break;
|
|
default:
|
|
throw Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
|
|
}
|
|
if (!inDestructuring) {
|
|
const effectiveName = getPropertyNameForPropertyNameNode(name);
|
|
if (effectiveName === void 0) {
|
|
continue;
|
|
}
|
|
const existingKind = seen.get(effectiveName);
|
|
if (!existingKind) {
|
|
seen.set(effectiveName, currentKind);
|
|
} else {
|
|
if (currentKind & 8 /* Method */ && existingKind & 8 /* Method */) {
|
|
grammarErrorOnNode(name, Diagnostics.Duplicate_identifier_0, getTextOfNode(name));
|
|
} else if (currentKind & 4 /* PropertyAssignment */ && existingKind & 4 /* PropertyAssignment */) {
|
|
grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name, getTextOfNode(name));
|
|
} else if (currentKind & 3 /* GetOrSetAccessor */ && existingKind & 3 /* GetOrSetAccessor */) {
|
|
if (existingKind !== 3 /* GetOrSetAccessor */ && currentKind !== existingKind) {
|
|
seen.set(effectiveName, currentKind | existingKind);
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
|
|
}
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxElement(node) {
|
|
checkGrammarJsxName(node.tagName);
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
const seen = /* @__PURE__ */ new Map();
|
|
for (const attr of node.attributes.properties) {
|
|
if (attr.kind === 290 /* JsxSpreadAttribute */) {
|
|
continue;
|
|
}
|
|
const { name, initializer } = attr;
|
|
if (!seen.get(name.escapedText)) {
|
|
seen.set(name.escapedText, true);
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
|
|
}
|
|
if (initializer && initializer.kind === 291 /* JsxExpression */ && !initializer.expression) {
|
|
return grammarErrorOnNode(initializer, Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxName(node) {
|
|
if (isPropertyAccessExpression(node)) {
|
|
let propName = node;
|
|
do {
|
|
const check2 = checkGrammarJsxNestedIdentifier(propName.name);
|
|
if (check2) {
|
|
return check2;
|
|
}
|
|
propName = propName.expression;
|
|
} while (isPropertyAccessExpression(propName));
|
|
const check = checkGrammarJsxNestedIdentifier(propName);
|
|
if (check) {
|
|
return check;
|
|
}
|
|
}
|
|
function checkGrammarJsxNestedIdentifier(name) {
|
|
if (isIdentifier(name) && idText(name).indexOf(":") !== -1) {
|
|
return grammarErrorOnNode(name, Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxExpression(node) {
|
|
if (node.expression && isCommaSequence(node.expression)) {
|
|
return grammarErrorOnNode(node.expression, 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 /* ForOfStatement */ && forInOrOfStatement.awaitModifier) {
|
|
if (!(forInOrOfStatement.flags & 32768 /* AwaitContext */)) {
|
|
const sourceFile = getSourceFileOfNode(forInOrOfStatement);
|
|
if (isInTopLevelContext(forInOrOfStatement)) {
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
if (!isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
diagnostics.add(createDiagnosticForNode(
|
|
forInOrOfStatement.awaitModifier,
|
|
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 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
if (sourceFile.impliedNodeFormat === 1 /* CommonJS */) {
|
|
diagnostics.add(
|
|
createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)
|
|
);
|
|
break;
|
|
}
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 4 /* System */:
|
|
if (languageVersion >= 4 /* ES2017 */) {
|
|
break;
|
|
}
|
|
default:
|
|
diagnostics.add(
|
|
createDiagnosticForNode(
|
|
forInOrOfStatement.awaitModifier,
|
|
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 {
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const diagnostic = createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
|
|
const func = getContainingFunction(forInOrOfStatement);
|
|
if (func && func.kind !== 173 /* Constructor */) {
|
|
Debug.assert((getFunctionFlags(func) & 2 /* Async */) === 0, "Enclosing function should never be an async function.");
|
|
const relatedInfo = createDiagnosticForNode(func, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
|
|
addRelatedInfo(diagnostic, relatedInfo);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (isForOfStatement(forInOrOfStatement) && !(forInOrOfStatement.flags & 32768 /* AwaitContext */) && isIdentifier(forInOrOfStatement.initializer) && forInOrOfStatement.initializer.escapedText === "async") {
|
|
grammarErrorOnNode(forInOrOfStatement.initializer, Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async);
|
|
return false;
|
|
}
|
|
if (forInOrOfStatement.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variableList = forInOrOfStatement.initializer;
|
|
if (!checkGrammarVariableDeclarationList(variableList)) {
|
|
const declarations = variableList.declarations;
|
|
if (!declarations.length) {
|
|
return false;
|
|
}
|
|
if (declarations.length > 1) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
|
|
return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
|
|
}
|
|
const firstDeclaration = declarations[0];
|
|
if (firstDeclaration.initializer) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
|
|
return grammarErrorOnNode(firstDeclaration.name, diagnostic);
|
|
}
|
|
if (firstDeclaration.type) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : 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 /* Ambient */) && accessor.parent.kind !== 184 /* TypeLiteral */ && accessor.parent.kind !== 261 /* InterfaceDeclaration */) {
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(accessor.name)) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 256 /* Abstract */)) {
|
|
return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
|
|
}
|
|
}
|
|
if (accessor.body) {
|
|
if (hasSyntacticModifier(accessor, 256 /* Abstract */)) {
|
|
return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
|
|
}
|
|
if (accessor.parent.kind === 184 /* TypeLiteral */ || accessor.parent.kind === 261 /* InterfaceDeclaration */) {
|
|
return grammarErrorOnNode(accessor.body, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
|
|
}
|
|
}
|
|
if (accessor.typeParameters) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_have_type_parameters);
|
|
}
|
|
if (!doesAccessorHaveCorrectParameterCount(accessor)) {
|
|
return grammarErrorOnNode(
|
|
accessor.name,
|
|
accessor.kind === 174 /* GetAccessor */ ? Diagnostics.A_get_accessor_cannot_have_parameters : Diagnostics.A_set_accessor_must_have_exactly_one_parameter
|
|
);
|
|
}
|
|
if (accessor.kind === 175 /* SetAccessor */) {
|
|
if (accessor.type) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
|
|
}
|
|
const parameter = Debug.checkDefined(getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion.");
|
|
if (parameter.dotDotDotToken) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_set_accessor_cannot_have_rest_parameter);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function doesAccessorHaveCorrectParameterCount(accessor) {
|
|
return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 174 /* GetAccessor */ ? 0 : 1);
|
|
}
|
|
function getAccessorThisParameter(accessor) {
|
|
if (accessor.parameters.length === (accessor.kind === 174 /* GetAccessor */ ? 1 : 2)) {
|
|
return getThisParameter(accessor);
|
|
}
|
|
}
|
|
function checkGrammarTypeOperatorNode(node) {
|
|
if (node.operator === 156 /* UniqueKeyword */) {
|
|
if (node.type.kind !== 153 /* SymbolKeyword */) {
|
|
return grammarErrorOnNode(node.type, Diagnostics._0_expected, tokenToString(153 /* SymbolKeyword */));
|
|
}
|
|
let parent = walkUpParenthesizedTypes(node.parent);
|
|
if (isInJSFile(parent) && isJSDocTypeExpression(parent)) {
|
|
const host2 = getJSDocHost(parent);
|
|
if (host2) {
|
|
parent = getSingleVariableOfVariableStatement(host2) || host2;
|
|
}
|
|
}
|
|
switch (parent.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
const decl = parent;
|
|
if (decl.name.kind !== 79 /* Identifier */) {
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name);
|
|
}
|
|
if (!isVariableDeclarationInVariableStatement(decl)) {
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement);
|
|
}
|
|
if (!(decl.parent.flags & 2 /* Const */)) {
|
|
return grammarErrorOnNode(parent.name, Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const);
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (!isStatic(parent) || !hasEffectiveReadonlyModifier(parent)) {
|
|
return grammarErrorOnNode(parent.name, Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly);
|
|
}
|
|
break;
|
|
case 168 /* PropertySignature */:
|
|
if (!hasSyntacticModifier(parent, 64 /* Readonly */)) {
|
|
return grammarErrorOnNode(parent.name, Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
|
|
}
|
|
break;
|
|
default:
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_not_allowed_here);
|
|
}
|
|
} else if (node.operator === 146 /* ReadonlyKeyword */) {
|
|
if (node.type.kind !== 185 /* ArrayType */ && node.type.kind !== 186 /* TupleType */) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, tokenToString(153 /* SymbolKeyword */));
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarForInvalidDynamicName(node, message) {
|
|
if (isNonBindableDynamicName(node)) {
|
|
return grammarErrorOnNode(node, message);
|
|
}
|
|
}
|
|
function checkGrammarMethod(node) {
|
|
if (checkGrammarFunctionLikeDeclaration(node)) {
|
|
return true;
|
|
}
|
|
if (node.kind === 171 /* MethodDeclaration */) {
|
|
if (node.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (node.modifiers && !(node.modifiers.length === 1 && first(node.modifiers).kind === 132 /* AsyncKeyword */)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here);
|
|
} else if (checkGrammarForInvalidQuestionMark(node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional)) {
|
|
return true;
|
|
} else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) {
|
|
return true;
|
|
} else if (node.body === void 0) {
|
|
return grammarErrorAtPos(node, node.end - 1, ";".length, Diagnostics._0_expected, "{");
|
|
}
|
|
}
|
|
if (checkGrammarForGenerator(node)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (isClassLike(node.parent)) {
|
|
if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(node.name)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, 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 /* MethodDeclaration */ && !node.body) {
|
|
return checkGrammarForInvalidDynamicName(node.name, 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 /* InterfaceDeclaration */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, 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 /* TypeLiteral */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, 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) {
|
|
let current = node;
|
|
while (current) {
|
|
if (isFunctionLikeOrClassStaticBlockDeclaration(current)) {
|
|
return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);
|
|
}
|
|
switch (current.kind) {
|
|
case 253 /* LabeledStatement */:
|
|
if (node.label && current.label.escapedText === node.label.escapedText) {
|
|
const isMisplacedContinueLabel = node.kind === 248 /* ContinueStatement */ && !isIterationStatement(current.statement, true);
|
|
if (isMisplacedContinueLabel) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
|
|
}
|
|
return false;
|
|
}
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
if (node.kind === 249 /* BreakStatement */ && !node.label) {
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
if (isIterationStatement(current, false) && !node.label) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
current = current.parent;
|
|
}
|
|
if (node.label) {
|
|
const message = node.kind === 249 /* BreakStatement */ ? Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
|
|
return grammarErrorOnNode(node, message);
|
|
} else {
|
|
const message = node.kind === 249 /* BreakStatement */ ? Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
|
|
return grammarErrorOnNode(node, message);
|
|
}
|
|
}
|
|
function checkGrammarBindingElement(node) {
|
|
if (node.dotDotDotToken) {
|
|
const elements = node.parent.elements;
|
|
if (node !== last(elements)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
}
|
|
checkGrammarForDisallowedTrailingComma(elements, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
if (node.propertyName) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.A_rest_element_cannot_have_a_property_name);
|
|
}
|
|
}
|
|
if (node.dotDotDotToken && node.initializer) {
|
|
return grammarErrorAtPos(node, node.initializer.pos - 1, 1, Diagnostics.A_rest_element_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
function isStringOrNumberLiteralExpression(expr) {
|
|
return isStringOrNumericLiteralLike(expr) || expr.kind === 221 /* PrefixUnaryExpression */ && expr.operator === 40 /* MinusToken */ && expr.operand.kind === 8 /* NumericLiteral */;
|
|
}
|
|
function isBigIntLiteralExpression(expr) {
|
|
return expr.kind === 9 /* BigIntLiteral */ || expr.kind === 221 /* PrefixUnaryExpression */ && expr.operator === 40 /* MinusToken */ && expr.operand.kind === 9 /* BigIntLiteral */;
|
|
}
|
|
function isSimpleLiteralEnumReference(expr) {
|
|
if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression)) && isEntityNameExpression(expr.expression)) {
|
|
return !!(checkExpressionCached(expr).flags & 1024 /* EnumLiteral */);
|
|
}
|
|
}
|
|
function checkAmbientInitializer(node) {
|
|
const initializer = node.initializer;
|
|
if (initializer) {
|
|
const isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) || isSimpleLiteralEnumReference(initializer) || initializer.kind === 110 /* TrueKeyword */ || initializer.kind === 95 /* FalseKeyword */ || isBigIntLiteralExpression(initializer));
|
|
const isConstOrReadonly = isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node);
|
|
if (isConstOrReadonly && !node.type) {
|
|
if (isInvalidInitializer) {
|
|
return grammarErrorOnNode(initializer, Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference);
|
|
}
|
|
} else {
|
|
return grammarErrorOnNode(initializer, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarVariableDeclaration(node) {
|
|
if (node.parent.parent.kind !== 246 /* ForInStatement */ && node.parent.parent.kind !== 247 /* ForOfStatement */) {
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
checkAmbientInitializer(node);
|
|
} else if (!node.initializer) {
|
|
if (isBindingPattern(node.name) && !isBindingPattern(node.parent)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_destructuring_declaration_must_have_an_initializer);
|
|
}
|
|
if (isVarConst(node)) {
|
|
return grammarErrorOnNode(node, Diagnostics.const_declarations_must_be_initialized);
|
|
}
|
|
}
|
|
}
|
|
if (node.exclamationToken && (node.parent.parent.kind !== 240 /* VariableStatement */ || !node.type || node.initializer || node.flags & 16777216 /* Ambient */)) {
|
|
const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
|
|
return grammarErrorOnNode(node.exclamationToken, message);
|
|
}
|
|
if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 16777216 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
|
|
checkESModuleMarker(node.name);
|
|
}
|
|
const checkLetConstNames = isLet(node) || isVarConst(node);
|
|
return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name);
|
|
}
|
|
function checkESModuleMarker(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (idText(name) === "__esModule") {
|
|
return grammarErrorOnNodeSkippedOn("noEmit", name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
|
|
}
|
|
} else {
|
|
const elements = name.elements;
|
|
for (const element of elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
return checkESModuleMarker(element.name);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNameInLetOrConstDeclarations(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (name.originalKeywordKind === 119 /* LetKeyword */) {
|
|
return grammarErrorOnNode(name, Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
|
|
}
|
|
} else {
|
|
const elements = name.elements;
|
|
for (const element of elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
checkGrammarNameInLetOrConstDeclarations(element.name);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarVariableDeclarationList(declarationList) {
|
|
const declarations = declarationList.declarations;
|
|
if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
|
|
return true;
|
|
}
|
|
if (!declarationList.declarations.length) {
|
|
return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
|
|
}
|
|
return false;
|
|
}
|
|
function allowLetAndConstDeclarations(parent) {
|
|
switch (parent.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return false;
|
|
case 253 /* LabeledStatement */:
|
|
return allowLetAndConstDeclarations(parent.parent);
|
|
}
|
|
return true;
|
|
}
|
|
function checkGrammarForDisallowedLetOrConstStatement(node) {
|
|
if (!allowLetAndConstDeclarations(node.parent)) {
|
|
if (isLet(node.declarationList)) {
|
|
return grammarErrorOnNode(node, Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
|
|
} else if (isVarConst(node.declarationList)) {
|
|
return grammarErrorOnNode(node, Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarMetaProperty(node) {
|
|
const escapedText = node.name.escapedText;
|
|
switch (node.keywordToken) {
|
|
case 103 /* NewKeyword */:
|
|
if (escapedText !== "target") {
|
|
return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "target");
|
|
}
|
|
break;
|
|
case 100 /* ImportKeyword */:
|
|
if (escapedText !== "meta") {
|
|
return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "meta");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function hasParseDiagnostics(sourceFile) {
|
|
return sourceFile.parseDiagnostics.length > 0;
|
|
}
|
|
function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorAtPos(nodeForSourceFile, start, length2, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(nodeForSourceFile);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
diagnostics.add(createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
errorSkippedOn(key, node, message, arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarConstructorTypeParameters(node) {
|
|
const jsdocTypeParameters = isInJSFile(node) ? getJSDocTypeParameterDeclarations(node) : void 0;
|
|
const range = node.typeParameters || jsdocTypeParameters && firstOrUndefined(jsdocTypeParameters);
|
|
if (range) {
|
|
const pos = range.pos === range.end ? range.pos : skipTrivia(getSourceFileOfNode(node).text, range.pos);
|
|
return grammarErrorAtPos(node, pos, range.end - pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
|
|
}
|
|
}
|
|
function checkGrammarConstructorTypeAnnotation(node) {
|
|
const type = node.type || getEffectiveReturnTypeNode(node);
|
|
if (type) {
|
|
return grammarErrorOnNode(type, Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
|
|
}
|
|
}
|
|
function checkGrammarProperty(node) {
|
|
if (isComputedPropertyName(node.name) && isBinaryExpression(node.name.expression) && node.name.expression.operatorToken.kind === 101 /* InKeyword */) {
|
|
return grammarErrorOnNode(
|
|
node.parent.members[0],
|
|
Diagnostics.A_mapped_type_may_not_declare_properties_or_methods
|
|
);
|
|
}
|
|
if (isClassLike(node.parent)) {
|
|
if (isStringLiteral(node.name) && node.name.text === "constructor") {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Classes_may_not_have_a_field_named_constructor);
|
|
}
|
|
if (checkGrammarForInvalidDynamicName(node.name, 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 /* ES2015 */ && isPrivateIdentifier(node.name)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */ && isAutoAccessorPropertyDeclaration(node)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (isAutoAccessorPropertyDeclaration(node) && checkGrammarForInvalidQuestionMark(node.questionToken, Diagnostics.An_accessor_property_cannot_be_declared_optional)) {
|
|
return true;
|
|
}
|
|
} else if (node.parent.kind === 261 /* InterfaceDeclaration */) {
|
|
if (checkGrammarForInvalidDynamicName(node.name, 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;
|
|
}
|
|
Debug.assertNode(node, isPropertySignature);
|
|
if (node.initializer) {
|
|
return grammarErrorOnNode(node.initializer, Diagnostics.An_interface_property_cannot_have_an_initializer);
|
|
}
|
|
} else if (isTypeLiteralNode(node.parent)) {
|
|
if (checkGrammarForInvalidDynamicName(node.name, 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;
|
|
}
|
|
Debug.assertNode(node, isPropertySignature);
|
|
if (node.initializer) {
|
|
return grammarErrorOnNode(node.initializer, Diagnostics.A_type_literal_property_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
checkAmbientInitializer(node);
|
|
}
|
|
if (isPropertyDeclaration(node) && node.exclamationToken && (!isClassLike(node.parent) || !node.type || node.initializer || node.flags & 16777216 /* Ambient */ || isStatic(node) || hasAbstractModifier(node))) {
|
|
const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
|
|
return grammarErrorOnNode(node.exclamationToken, message);
|
|
}
|
|
}
|
|
function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */ || node.kind === 262 /* TypeAliasDeclaration */ || node.kind === 269 /* ImportDeclaration */ || node.kind === 268 /* ImportEqualsDeclaration */ || node.kind === 275 /* ExportDeclaration */ || node.kind === 274 /* ExportAssignment */ || node.kind === 267 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 2 /* Ambient */ | 1 /* Export */ | 1024 /* Default */)) {
|
|
return false;
|
|
}
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
|
|
}
|
|
function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) {
|
|
for (const decl of file.statements) {
|
|
if (isDeclaration(decl) || decl.kind === 240 /* VariableStatement */) {
|
|
if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarSourceFile(node) {
|
|
return !!(node.flags & 16777216 /* Ambient */) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
|
|
}
|
|
function checkGrammarStatementInAmbientContext(node) {
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.hasReportedStatementInAmbientContext && (isFunctionLike(node.parent) || isAccessor(node.parent))) {
|
|
return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
|
|
}
|
|
if (node.parent.kind === 238 /* Block */ || node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
const links2 = getNodeLinks(node.parent);
|
|
if (!links2.hasReportedStatementInAmbientContext) {
|
|
return links2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
|
|
}
|
|
} else {
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNumericLiteral(node) {
|
|
if (node.numericLiteralFlags & 32 /* Octal */) {
|
|
let diagnosticMessage;
|
|
if (languageVersion >= 1 /* ES5 */) {
|
|
diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
|
|
} else if (isChildOfNodeWithKind(node, 198 /* LiteralType */)) {
|
|
diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
|
|
} else if (isChildOfNodeWithKind(node, 302 /* EnumMember */)) {
|
|
diagnosticMessage = Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
|
|
}
|
|
if (diagnosticMessage) {
|
|
const withMinus = isPrefixUnaryExpression(node.parent) && node.parent.operator === 40 /* MinusToken */;
|
|
const literal = (withMinus ? "-" : "") + "0o" + node.text;
|
|
return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
|
|
}
|
|
}
|
|
checkNumericLiteralValueSize(node);
|
|
return false;
|
|
}
|
|
function checkNumericLiteralValueSize(node) {
|
|
const isFractional = getTextOfNode(node).indexOf(".") !== -1;
|
|
const isScientific = node.numericLiteralFlags & 16 /* Scientific */;
|
|
if (isFractional || isScientific) {
|
|
return;
|
|
}
|
|
const value = +node.text;
|
|
if (value <= 2 ** 53 - 1) {
|
|
return;
|
|
}
|
|
addErrorOrSuggestion(false, createDiagnosticForNode(node, Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
|
|
}
|
|
function checkGrammarBigIntLiteral(node) {
|
|
const literalType = isLiteralTypeNode(node.parent) || isPrefixUnaryExpression(node.parent) && isLiteralTypeNode(node.parent.parent);
|
|
if (!literalType) {
|
|
if (languageVersion < 7 /* ES2020 */) {
|
|
if (grammarErrorOnNode(node, Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, textSpanEnd(span), 0, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getAmbientModules() {
|
|
if (!ambientModulesCache) {
|
|
ambientModulesCache = [];
|
|
globals.forEach((global2, sym) => {
|
|
if (ambientModuleSymbolRegex.test(sym)) {
|
|
ambientModulesCache.push(global2);
|
|
}
|
|
});
|
|
}
|
|
return ambientModulesCache;
|
|
}
|
|
function checkGrammarImportClause(node) {
|
|
var _a2;
|
|
if (node.isTypeOnly && node.name && node.namedBindings) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both);
|
|
}
|
|
if (node.isTypeOnly && ((_a2 = node.namedBindings) == null ? void 0 : _a2.kind) === 272 /* NamedImports */) {
|
|
return checkGrammarNamedImportsOrExports(node.namedBindings);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNamedImportsOrExports(namedBindings) {
|
|
return !!forEach(namedBindings.elements, (specifier) => {
|
|
if (specifier.isTypeOnly) {
|
|
return grammarErrorOnFirstToken(
|
|
specifier,
|
|
specifier.kind === 273 /* ImportSpecifier */ ? Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement : 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 === 5 /* ES2015 */) {
|
|
return grammarErrorOnNode(node, 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, Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
|
|
}
|
|
const nodeArguments = node.arguments;
|
|
if (moduleKind !== 99 /* ESNext */ && moduleKind !== 199 /* NodeNext */ && moduleKind !== 100 /* Node16 */) {
|
|
checkGrammarForDisallowedTrailingComma(nodeArguments);
|
|
if (nodeArguments.length > 1) {
|
|
const assertionArgument = nodeArguments[1];
|
|
return grammarErrorOnNode(assertionArgument, 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, Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments);
|
|
}
|
|
const spreadElement = find(nodeArguments, isSpreadElement);
|
|
if (spreadElement) {
|
|
return grammarErrorOnNode(spreadElement, Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element);
|
|
}
|
|
return false;
|
|
}
|
|
function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) {
|
|
const sourceObjectFlags = getObjectFlags(source);
|
|
if (sourceObjectFlags & (4 /* Reference */ | 16 /* Anonymous */) && unionTarget.flags & 1048576 /* Union */) {
|
|
return find(unionTarget.types, (target) => {
|
|
if (target.flags & 524288 /* Object */) {
|
|
const overlapObjFlags = sourceObjectFlags & getObjectFlags(target);
|
|
if (overlapObjFlags & 4 /* Reference */) {
|
|
return source.target === target.target;
|
|
}
|
|
if (overlapObjFlags & 16 /* Anonymous */) {
|
|
return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
function findBestTypeForObjectLiteral(source, unionTarget) {
|
|
if (getObjectFlags(source) & 128 /* ObjectLiteral */ && someType(unionTarget, isArrayLikeType)) {
|
|
return find(unionTarget.types, (t) => !isArrayLikeType(t));
|
|
}
|
|
}
|
|
function findBestTypeForInvokable(source, unionTarget) {
|
|
let signatureKind = 0 /* Call */;
|
|
const hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 || (signatureKind = 1 /* Construct */, getSignaturesOfType(source, signatureKind).length > 0);
|
|
if (hasSignatures) {
|
|
return find(unionTarget.types, (t) => getSignaturesOfType(t, signatureKind).length > 0);
|
|
}
|
|
}
|
|
function findMostOverlappyType(source, unionTarget) {
|
|
let bestMatch;
|
|
if (!(source.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
|
|
let matchingCount = 0;
|
|
for (const target of unionTarget.types) {
|
|
if (!(target.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
|
|
const overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
|
|
if (overlap.flags & 4194304 /* Index */) {
|
|
return target;
|
|
} else if (isUnitType(overlap) || overlap.flags & 1048576 /* Union */) {
|
|
const len = overlap.flags & 1048576 /* Union */ ? countWhere(overlap.types, isUnitType) : 1;
|
|
if (len >= matchingCount) {
|
|
bestMatch = target;
|
|
matchingCount = len;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return bestMatch;
|
|
}
|
|
function filterPrimitivesIfContainsNonPrimitive(type) {
|
|
if (maybeTypeOfKind(type, 67108864 /* NonPrimitive */)) {
|
|
const result = filterType(type, (t) => !(t.flags & 131068 /* Primitive */));
|
|
if (!(result.flags & 131072 /* Never */)) {
|
|
return result;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
|
|
if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
|
|
const match = getMatchingUnionConstituentForType(target, source);
|
|
if (match) {
|
|
return match;
|
|
}
|
|
const sourceProperties = getPropertiesOfType(source);
|
|
if (sourceProperties) {
|
|
const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
|
|
if (sourcePropertiesFiltered) {
|
|
return discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo, void 0, skipPartial);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function isNotAccessor(declaration) {
|
|
return !isAccessor(declaration);
|
|
}
|
|
function isNotOverload(declaration) {
|
|
return declaration.kind !== 259 /* FunctionDeclaration */ && declaration.kind !== 171 /* MethodDeclaration */ || !!declaration.body;
|
|
}
|
|
function isDeclarationNameOrImportPropertyName(name) {
|
|
switch (name.parent.kind) {
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return isIdentifier(name);
|
|
default:
|
|
return isDeclarationName(name);
|
|
}
|
|
}
|
|
var JsxNames;
|
|
((JsxNames2) => {
|
|
JsxNames2.JSX = "JSX";
|
|
JsxNames2.IntrinsicElements = "IntrinsicElements";
|
|
JsxNames2.ElementClass = "ElementClass";
|
|
JsxNames2.ElementAttributesPropertyNameContainer = "ElementAttributesProperty";
|
|
JsxNames2.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute";
|
|
JsxNames2.Element = "Element";
|
|
JsxNames2.IntrinsicAttributes = "IntrinsicAttributes";
|
|
JsxNames2.IntrinsicClassAttributes = "IntrinsicClassAttributes";
|
|
JsxNames2.LibraryManagedAttributes = "LibraryManagedAttributes";
|
|
})(JsxNames || (JsxNames = {}));
|
|
function getIterationTypesKeyFromIterationTypeKind(typeKind) {
|
|
switch (typeKind) {
|
|
case 0 /* Yield */:
|
|
return "yieldType";
|
|
case 1 /* Return */:
|
|
return "returnType";
|
|
case 2 /* Next */:
|
|
return "nextType";
|
|
}
|
|
}
|
|
function signatureHasRestParameter(s) {
|
|
return !!(s.flags & 1 /* HasRestParameter */);
|
|
}
|
|
function signatureHasLiteralTypes(s) {
|
|
return !!(s.flags & 2 /* HasLiteralTypes */);
|
|
}
|
|
|
|
// src/compiler/visitorPublic.ts
|
|
function visitNode(node, visitor, test, lift) {
|
|
if (node === void 0 || visitor === void 0) {
|
|
return node;
|
|
}
|
|
const visited = visitor(node);
|
|
if (visited === node) {
|
|
return node;
|
|
}
|
|
let visitedNode;
|
|
if (visited === void 0) {
|
|
return void 0;
|
|
} else if (isArray(visited)) {
|
|
visitedNode = (lift || extractSingleNode)(visited);
|
|
} else {
|
|
visitedNode = visited;
|
|
}
|
|
Debug.assertNode(visitedNode, test);
|
|
return visitedNode;
|
|
}
|
|
function visitNodes2(nodes, visitor, test, start, count) {
|
|
if (nodes === void 0 || visitor === void 0) {
|
|
return nodes;
|
|
}
|
|
const length2 = nodes.length;
|
|
if (start === void 0 || start < 0) {
|
|
start = 0;
|
|
}
|
|
if (count === void 0 || count > length2 - start) {
|
|
count = length2 - start;
|
|
}
|
|
let hasTrailingComma;
|
|
let pos = -1;
|
|
let end = -1;
|
|
if (start > 0 || count < length2) {
|
|
hasTrailingComma = nodes.hasTrailingComma && start + count === length2;
|
|
} else {
|
|
pos = nodes.pos;
|
|
end = nodes.end;
|
|
hasTrailingComma = nodes.hasTrailingComma;
|
|
}
|
|
const updated = visitArrayWorker(nodes, visitor, test, start, count);
|
|
if (updated !== nodes) {
|
|
const updatedArray = factory.createNodeArray(updated, hasTrailingComma);
|
|
setTextRangePosEnd(updatedArray, pos, end);
|
|
return updatedArray;
|
|
}
|
|
return nodes;
|
|
}
|
|
function visitArray(nodes, visitor, test, start, count) {
|
|
if (nodes === void 0) {
|
|
return nodes;
|
|
}
|
|
const length2 = nodes.length;
|
|
if (start === void 0 || start < 0) {
|
|
start = 0;
|
|
}
|
|
if (count === void 0 || count > length2 - start) {
|
|
count = length2 - start;
|
|
}
|
|
return visitArrayWorker(nodes, visitor, test, start, count);
|
|
}
|
|
function visitArrayWorker(nodes, visitor, test, start, count) {
|
|
let updated;
|
|
const length2 = nodes.length;
|
|
if (start > 0 || count < length2) {
|
|
updated = [];
|
|
}
|
|
for (let i = 0; i < count; i++) {
|
|
const node = nodes[i + start];
|
|
const visited = node !== void 0 ? visitor(node) : void 0;
|
|
if (updated !== void 0 || visited === void 0 || visited !== node) {
|
|
if (updated === void 0) {
|
|
updated = nodes.slice(0, i);
|
|
}
|
|
if (visited) {
|
|
if (isArray(visited)) {
|
|
for (const visitedNode of visited) {
|
|
void Debug.assertNode(visitedNode, test);
|
|
updated.push(visitedNode);
|
|
}
|
|
} else {
|
|
void Debug.assertNode(visited, test);
|
|
updated.push(visited);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return updated != null ? updated : nodes;
|
|
}
|
|
function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict, nodesVisitor = visitNodes2) {
|
|
context.startLexicalEnvironment();
|
|
statements = nodesVisitor(statements, visitor, isStatement, start);
|
|
if (ensureUseStrict)
|
|
statements = context.factory.ensureUseStrict(statements);
|
|
return factory.mergeLexicalEnvironment(statements, context.endLexicalEnvironment());
|
|
}
|
|
function visitParameterList(nodes, visitor, context, nodesVisitor = visitNodes2) {
|
|
let updated;
|
|
context.startLexicalEnvironment();
|
|
if (nodes) {
|
|
context.setLexicalEnvironmentFlags(1 /* InParameters */, true);
|
|
updated = nodesVisitor(nodes, visitor, isParameterDeclaration);
|
|
if (context.getLexicalEnvironmentFlags() & 2 /* VariablesHoistedInParameters */ && getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ES2015 */) {
|
|
updated = addDefaultValueAssignmentsIfNeeded(updated, context);
|
|
}
|
|
context.setLexicalEnvironmentFlags(1 /* InParameters */, false);
|
|
}
|
|
context.suspendLexicalEnvironment();
|
|
return updated;
|
|
}
|
|
function addDefaultValueAssignmentsIfNeeded(parameters, context) {
|
|
let result;
|
|
for (let i = 0; i < parameters.length; i++) {
|
|
const parameter = parameters[i];
|
|
const updated = addDefaultValueAssignmentIfNeeded(parameter, context);
|
|
if (result || updated !== parameter) {
|
|
if (!result)
|
|
result = parameters.slice(0, i);
|
|
result[i] = updated;
|
|
}
|
|
}
|
|
if (result) {
|
|
return setTextRange(context.factory.createNodeArray(result, parameters.hasTrailingComma), parameters);
|
|
}
|
|
return parameters;
|
|
}
|
|
function addDefaultValueAssignmentIfNeeded(parameter, context) {
|
|
return parameter.dotDotDotToken ? parameter : isBindingPattern(parameter.name) ? addDefaultValueAssignmentForBindingPattern(parameter, context) : parameter.initializer ? addDefaultValueAssignmentForInitializer(parameter, parameter.name, parameter.initializer, context) : parameter;
|
|
}
|
|
function addDefaultValueAssignmentForBindingPattern(parameter, context) {
|
|
const { factory: factory2 } = context;
|
|
context.addInitializationStatement(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
parameter.name,
|
|
void 0,
|
|
parameter.type,
|
|
parameter.initializer ? factory2.createConditionalExpression(
|
|
factory2.createStrictEquality(
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
factory2.createVoidZero()
|
|
),
|
|
void 0,
|
|
parameter.initializer,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
) : factory2.getGeneratedNameForNode(parameter)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
return factory2.updateParameterDeclaration(
|
|
parameter,
|
|
parameter.modifiers,
|
|
parameter.dotDotDotToken,
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
parameter.questionToken,
|
|
parameter.type,
|
|
void 0
|
|
);
|
|
}
|
|
function addDefaultValueAssignmentForInitializer(parameter, name, initializer, context) {
|
|
const factory2 = context.factory;
|
|
context.addInitializationStatement(
|
|
factory2.createIfStatement(
|
|
factory2.createTypeCheck(factory2.cloneNode(name), "undefined"),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
setEmitFlags(factory2.cloneNode(name), 96 /* NoSourceMap */),
|
|
setEmitFlags(initializer, 96 /* NoSourceMap */ | getEmitFlags(initializer) | 3072 /* NoComments */)
|
|
),
|
|
parameter
|
|
),
|
|
3072 /* NoComments */
|
|
)
|
|
)
|
|
]),
|
|
parameter
|
|
),
|
|
1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */
|
|
)
|
|
)
|
|
);
|
|
return factory2.updateParameterDeclaration(
|
|
parameter,
|
|
parameter.modifiers,
|
|
parameter.dotDotDotToken,
|
|
parameter.name,
|
|
parameter.questionToken,
|
|
parameter.type,
|
|
void 0
|
|
);
|
|
}
|
|
function visitFunctionBody(node, visitor, context, nodeVisitor = visitNode) {
|
|
context.resumeLexicalEnvironment();
|
|
const updated = nodeVisitor(node, visitor, isConciseBody);
|
|
const declarations = context.endLexicalEnvironment();
|
|
if (some(declarations)) {
|
|
if (!updated) {
|
|
return context.factory.createBlock(declarations);
|
|
}
|
|
const block = context.factory.converters.convertToFunctionBlock(updated);
|
|
const statements = factory.mergeLexicalEnvironment(block.statements, declarations);
|
|
return context.factory.updateBlock(block, statements);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitIterationBody(body, visitor, context, nodeVisitor = visitNode) {
|
|
context.startBlockScope();
|
|
const updated = nodeVisitor(body, visitor, isStatement, context.factory.liftToBlock);
|
|
const declarations = context.endBlockScope();
|
|
if (some(declarations)) {
|
|
if (isBlock(updated)) {
|
|
declarations.push(...updated.statements);
|
|
return context.factory.updateBlock(updated, declarations);
|
|
}
|
|
declarations.push(updated);
|
|
return context.factory.createBlock(declarations);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitEachChild(node, visitor, context, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
|
|
if (node === void 0) {
|
|
return void 0;
|
|
}
|
|
const fn = visitEachChildTable[node.kind];
|
|
return fn === void 0 ? node : fn(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor);
|
|
}
|
|
var visitEachChildTable = {
|
|
[79 /* Identifier */]: function visitEachChildOfIdentifier(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIdentifier(
|
|
node,
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration)
|
|
);
|
|
},
|
|
[163 /* QualifiedName */]: function visitEachChildOfQualifiedName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateQualifiedName(
|
|
node,
|
|
nodeVisitor(node.left, visitor, isEntityName),
|
|
nodeVisitor(node.right, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[164 /* ComputedPropertyName */]: function visitEachChildOfComputedPropertyName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateComputedPropertyName(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[165 /* TypeParameter */]: function visitEachChildOfTypeParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeParameterDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.constraint, visitor, isTypeNode),
|
|
nodeVisitor(node.default, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[166 /* Parameter */]: function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateParameterDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[167 /* Decorator */]: function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDecorator(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[168 /* PropertySignature */]: function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updatePropertySignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[169 /* PropertyDeclaration */]: function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
var _a2;
|
|
return context.factory.updatePropertyDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor((_a2 = node.questionToken) != null ? _a2 : node.exclamationToken, tokenVisitor, isQuestionOrExclamationToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[170 /* MethodSignature */]: function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMethodSignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[171 /* MethodDeclaration */]: function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMethodDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[173 /* Constructor */]: function visitEachChildOfConstructorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[174 /* GetAccessor */]: function visitEachChildOfGetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateGetAccessorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[175 /* SetAccessor */]: function visitEachChildOfSetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSetAccessorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[172 /* ClassStaticBlockDeclaration */]: function visitEachChildOfClassStaticBlockDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
context.startLexicalEnvironment();
|
|
context.suspendLexicalEnvironment();
|
|
return context.factory.updateClassStaticBlockDeclaration(
|
|
node,
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[176 /* CallSignature */]: function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCallSignature(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[177 /* ConstructSignature */]: function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructSignature(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[178 /* IndexSignature */]: function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIndexSignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[179 /* TypePredicate */]: function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypePredicateNode(
|
|
node,
|
|
nodeVisitor(node.assertsModifier, visitor, isAssertsKeyword),
|
|
nodeVisitor(node.parameterName, visitor, isIdentifierOrThisTypeNode),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[180 /* TypeReference */]: function visitEachChildOfTypeReferenceNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeReferenceNode(
|
|
node,
|
|
nodeVisitor(node.typeName, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[181 /* FunctionType */]: function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateFunctionTypeNode(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[182 /* ConstructorType */]: function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructorTypeNode(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[183 /* TypeQuery */]: function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeQueryNode(
|
|
node,
|
|
nodeVisitor(node.exprName, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[184 /* TypeLiteral */]: function visitEachChildOfTypeLiteralNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeLiteralNode(
|
|
node,
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[185 /* ArrayType */]: function visitEachChildOfArrayTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayTypeNode(
|
|
node,
|
|
nodeVisitor(node.elementType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[186 /* TupleType */]: function visitEachChildOfTupleTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTupleTypeNode(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[187 /* OptionalType */]: function visitEachChildOfOptionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateOptionalTypeNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[188 /* RestType */]: function visitEachChildOfRestTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateRestTypeNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[189 /* UnionType */]: function visitEachChildOfUnionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateUnionTypeNode(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[190 /* IntersectionType */]: function visitEachChildOfIntersectionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIntersectionTypeNode(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[191 /* ConditionalType */]: function visitEachChildOfConditionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConditionalTypeNode(
|
|
node,
|
|
nodeVisitor(node.checkType, visitor, isTypeNode),
|
|
nodeVisitor(node.extendsType, visitor, isTypeNode),
|
|
nodeVisitor(node.trueType, visitor, isTypeNode),
|
|
nodeVisitor(node.falseType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[192 /* InferType */]: function visitEachChildOfInferTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateInferTypeNode(
|
|
node,
|
|
nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration)
|
|
);
|
|
},
|
|
[202 /* ImportType */]: function visitEachChildOfImportTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportTypeNode(
|
|
node,
|
|
nodeVisitor(node.argument, visitor, isTypeNode),
|
|
nodeVisitor(node.assertions, visitor, isImportTypeAssertionContainer),
|
|
nodeVisitor(node.qualifier, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
node.isTypeOf
|
|
);
|
|
},
|
|
[298 /* ImportTypeAssertionContainer */]: function visitEachChildOfImportTypeAssertionContainer(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportTypeAssertionContainer(
|
|
node,
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause),
|
|
node.multiLine
|
|
);
|
|
},
|
|
[199 /* NamedTupleMember */]: function visitEachChildOfNamedTupleMember(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateNamedTupleMember(
|
|
node,
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[193 /* ParenthesizedType */]: function visitEachChildOfParenthesizedType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateParenthesizedType(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[195 /* TypeOperator */]: function visitEachChildOfTypeOperatorNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeOperatorNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[196 /* IndexedAccessType */]: function visitEachChildOfIndexedAccessType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIndexedAccessTypeNode(
|
|
node,
|
|
nodeVisitor(node.objectType, visitor, isTypeNode),
|
|
nodeVisitor(node.indexType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[197 /* MappedType */]: function visitEachChildOfMappedType(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMappedTypeNode(
|
|
node,
|
|
nodeVisitor(node.readonlyToken, tokenVisitor, isReadonlyKeywordOrPlusOrMinusToken),
|
|
nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration),
|
|
nodeVisitor(node.nameType, visitor, isTypeNode),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionOrPlusOrMinusToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[198 /* LiteralType */]: function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateLiteralTypeNode(
|
|
node,
|
|
nodeVisitor(node.literal, visitor, isExpression)
|
|
);
|
|
},
|
|
[200 /* TemplateLiteralType */]: function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateLiteralType(
|
|
node,
|
|
nodeVisitor(node.head, visitor, isTemplateHead),
|
|
nodesVisitor(node.templateSpans, visitor, isTemplateLiteralTypeSpan)
|
|
);
|
|
},
|
|
[201 /* TemplateLiteralTypeSpan */]: function visitEachChildOfTemplateLiteralTypeSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateLiteralTypeSpan(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)
|
|
);
|
|
},
|
|
[203 /* ObjectBindingPattern */]: function visitEachChildOfObjectBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateObjectBindingPattern(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isBindingElement)
|
|
);
|
|
},
|
|
[204 /* ArrayBindingPattern */]: function visitEachChildOfArrayBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayBindingPattern(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isArrayBindingElement)
|
|
);
|
|
},
|
|
[205 /* BindingElement */]: function visitEachChildOfBindingElement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateBindingElement(
|
|
node,
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.propertyName, visitor, isPropertyName),
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[206 /* ArrayLiteralExpression */]: function visitEachChildOfArrayLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayLiteralExpression(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExpression)
|
|
);
|
|
},
|
|
[207 /* ObjectLiteralExpression */]: function visitEachChildOfObjectLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateObjectLiteralExpression(
|
|
node,
|
|
nodesVisitor(node.properties, visitor, isObjectLiteralElementLike)
|
|
);
|
|
},
|
|
[208 /* PropertyAccessExpression */]: function visitEachChildOfPropertyAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isPropertyAccessChain(node) ? context.factory.updatePropertyAccessChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodeVisitor(node.name, visitor, isMemberName)
|
|
) : context.factory.updatePropertyAccessExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.name, visitor, isMemberName)
|
|
);
|
|
},
|
|
[209 /* ElementAccessExpression */]: function visitEachChildOfElementAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isElementAccessChain(node) ? context.factory.updateElementAccessChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodeVisitor(node.argumentExpression, visitor, isExpression)
|
|
) : context.factory.updateElementAccessExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
},
|
|
[210 /* CallExpression */]: function visitEachChildOfCallExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isCallChain(node) ? context.factory.updateCallChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
) : context.factory.updateCallExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
);
|
|
},
|
|
[211 /* NewExpression */]: function visitEachChildOfNewExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNewExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
);
|
|
},
|
|
[212 /* TaggedTemplateExpression */]: function visitEachChildOfTaggedTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTaggedTemplateExpression(
|
|
node,
|
|
nodeVisitor(node.tag, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
},
|
|
[213 /* TypeAssertionExpression */]: function visitEachChildOfTypeAssertionExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeAssertion(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[214 /* ParenthesizedExpression */]: function visitEachChildOfParenthesizedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateParenthesizedExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[215 /* FunctionExpression */]: function visitEachChildOfFunctionExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateFunctionExpression(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[216 /* ArrowFunction */]: function visitEachChildOfArrowFunction(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateArrowFunction(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, isEqualsGreaterThanToken),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[217 /* DeleteExpression */]: function visitEachChildOfDeleteExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDeleteExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[218 /* TypeOfExpression */]: function visitEachChildOfTypeOfExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeOfExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[219 /* VoidExpression */]: function visitEachChildOfVoidExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVoidExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[220 /* AwaitExpression */]: function visitEachChildOfAwaitExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAwaitExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[221 /* PrefixUnaryExpression */]: function visitEachChildOfPrefixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePrefixUnaryExpression(
|
|
node,
|
|
nodeVisitor(node.operand, visitor, isExpression)
|
|
);
|
|
},
|
|
[222 /* PostfixUnaryExpression */]: function visitEachChildOfPostfixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePostfixUnaryExpression(
|
|
node,
|
|
nodeVisitor(node.operand, visitor, isExpression)
|
|
);
|
|
},
|
|
[223 /* BinaryExpression */]: function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateBinaryExpression(
|
|
node,
|
|
nodeVisitor(node.left, visitor, isExpression),
|
|
nodeVisitor(node.operatorToken, tokenVisitor, isBinaryOperatorToken),
|
|
nodeVisitor(node.right, visitor, isExpression)
|
|
);
|
|
},
|
|
[224 /* ConditionalExpression */]: function visitEachChildOfConditionalExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateConditionalExpression(
|
|
node,
|
|
nodeVisitor(node.condition, visitor, isExpression),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.whenTrue, visitor, isExpression),
|
|
nodeVisitor(node.colonToken, tokenVisitor, isColonToken),
|
|
nodeVisitor(node.whenFalse, visitor, isExpression)
|
|
);
|
|
},
|
|
[225 /* TemplateExpression */]: function visitEachChildOfTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateExpression(
|
|
node,
|
|
nodeVisitor(node.head, visitor, isTemplateHead),
|
|
nodesVisitor(node.templateSpans, visitor, isTemplateSpan)
|
|
);
|
|
},
|
|
[226 /* YieldExpression */]: function visitEachChildOfYieldExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateYieldExpression(
|
|
node,
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[227 /* SpreadElement */]: function visitEachChildOfSpreadElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSpreadElement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[228 /* ClassExpression */]: function visitEachChildOfClassExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateClassExpression(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isClassElement)
|
|
);
|
|
},
|
|
[230 /* ExpressionWithTypeArguments */]: function visitEachChildOfExpressionWithTypeArguments(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExpressionWithTypeArguments(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[231 /* AsExpression */]: function visitEachChildOfAsExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAsExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[235 /* SatisfiesExpression */]: function visitEachChildOfSatisfiesExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSatisfiesExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[232 /* NonNullExpression */]: function visitEachChildOfNonNullExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return isOptionalChain(node) ? context.factory.updateNonNullChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
) : context.factory.updateNonNullExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[233 /* MetaProperty */]: function visitEachChildOfMetaProperty(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateMetaProperty(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[236 /* TemplateSpan */]: function visitEachChildOfTemplateSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateSpan(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)
|
|
);
|
|
},
|
|
[238 /* Block */]: function visitEachChildOfBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateBlock(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[240 /* VariableStatement */]: function visitEachChildOfVariableStatement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVariableStatement(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.declarationList, visitor, isVariableDeclarationList)
|
|
);
|
|
},
|
|
[241 /* ExpressionStatement */]: function visitEachChildOfExpressionStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExpressionStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[242 /* IfStatement */]: function visitEachChildOfIfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIfStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.thenStatement, visitor, isStatement, context.factory.liftToBlock),
|
|
nodeVisitor(node.elseStatement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[243 /* DoStatement */]: function visitEachChildOfDoStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDoStatement(
|
|
node,
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[244 /* WhileStatement */]: function visitEachChildOfWhileStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateWhileStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[245 /* ForStatement */]: function visitEachChildOfForStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateForStatement(
|
|
node,
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.condition, visitor, isExpression),
|
|
nodeVisitor(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[246 /* ForInStatement */]: function visitEachChildOfForInStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateForInStatement(
|
|
node,
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[247 /* ForOfStatement */]: function visitEachChildOfForOfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateForOfStatement(
|
|
node,
|
|
nodeVisitor(node.awaitModifier, tokenVisitor, isAwaitKeyword),
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[248 /* ContinueStatement */]: function visitEachChildOfContinueStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateContinueStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[249 /* BreakStatement */]: function visitEachChildOfBreakStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateBreakStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[250 /* ReturnStatement */]: function visitEachChildOfReturnStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateReturnStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[251 /* WithStatement */]: function visitEachChildOfWithStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateWithStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[252 /* SwitchStatement */]: function visitEachChildOfSwitchStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSwitchStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.caseBlock, visitor, isCaseBlock)
|
|
);
|
|
},
|
|
[253 /* LabeledStatement */]: function visitEachChildOfLabeledStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateLabeledStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier),
|
|
nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[254 /* ThrowStatement */]: function visitEachChildOfThrowStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateThrowStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[255 /* TryStatement */]: function visitEachChildOfTryStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTryStatement(
|
|
node,
|
|
nodeVisitor(node.tryBlock, visitor, isBlock),
|
|
nodeVisitor(node.catchClause, visitor, isCatchClause),
|
|
nodeVisitor(node.finallyBlock, visitor, isBlock)
|
|
);
|
|
},
|
|
[257 /* VariableDeclaration */]: function visitEachChildOfVariableDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateVariableDeclaration(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.exclamationToken, tokenVisitor, isExclamationToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[258 /* VariableDeclarationList */]: function visitEachChildOfVariableDeclarationList(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVariableDeclarationList(
|
|
node,
|
|
nodesVisitor(node.declarations, visitor, isVariableDeclaration)
|
|
);
|
|
},
|
|
[259 /* FunctionDeclaration */]: function visitEachChildOfFunctionDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateFunctionDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[260 /* ClassDeclaration */]: function visitEachChildOfClassDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateClassDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isClassElement)
|
|
);
|
|
},
|
|
[261 /* InterfaceDeclaration */]: function visitEachChildOfInterfaceDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateInterfaceDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[262 /* TypeAliasDeclaration */]: function visitEachChildOfTypeAliasDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeAliasDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[263 /* EnumDeclaration */]: function visitEachChildOfEnumDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateEnumDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.members, visitor, isEnumMember)
|
|
);
|
|
},
|
|
[264 /* ModuleDeclaration */]: function visitEachChildOfModuleDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateModuleDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isModuleName),
|
|
nodeVisitor(node.body, visitor, isModuleBody)
|
|
);
|
|
},
|
|
[265 /* ModuleBlock */]: function visitEachChildOfModuleBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateModuleBlock(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[266 /* CaseBlock */]: function visitEachChildOfCaseBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCaseBlock(
|
|
node,
|
|
nodesVisitor(node.clauses, visitor, isCaseOrDefaultClause)
|
|
);
|
|
},
|
|
[267 /* NamespaceExportDeclaration */]: function visitEachChildOfNamespaceExportDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceExportDeclaration(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[268 /* ImportEqualsDeclaration */]: function visitEachChildOfImportEqualsDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportEqualsDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.moduleReference, visitor, isModuleReference)
|
|
);
|
|
},
|
|
[269 /* ImportDeclaration */]: function visitEachChildOfImportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.importClause, visitor, isImportClause),
|
|
nodeVisitor(node.moduleSpecifier, visitor, isExpression),
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause)
|
|
);
|
|
},
|
|
[296 /* AssertClause */]: function visitEachChildOfAssertClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAssertClause(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isAssertEntry),
|
|
node.multiLine
|
|
);
|
|
},
|
|
[297 /* AssertEntry */]: function visitEachChildOfAssertEntry(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAssertEntry(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isAssertionKey),
|
|
nodeVisitor(node.value, visitor, isExpression)
|
|
);
|
|
},
|
|
[270 /* ImportClause */]: function visitEachChildOfImportClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportClause(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.namedBindings, visitor, isNamedImportBindings)
|
|
);
|
|
},
|
|
[271 /* NamespaceImport */]: function visitEachChildOfNamespaceImport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceImport(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[277 /* NamespaceExport */]: function visitEachChildOfNamespaceExport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceExport(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[272 /* NamedImports */]: function visitEachChildOfNamedImports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamedImports(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isImportSpecifier)
|
|
);
|
|
},
|
|
[273 /* ImportSpecifier */]: function visitEachChildOfImportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportSpecifier(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.propertyName, visitor, isIdentifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[274 /* ExportAssignment */]: function visitEachChildOfExportAssignment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportAssignment(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[275 /* ExportDeclaration */]: function visitEachChildOfExportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.exportClause, visitor, isNamedExportBindings),
|
|
nodeVisitor(node.moduleSpecifier, visitor, isExpression),
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause)
|
|
);
|
|
},
|
|
[276 /* NamedExports */]: function visitEachChildOfNamedExports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamedExports(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExportSpecifier)
|
|
);
|
|
},
|
|
[278 /* ExportSpecifier */]: function visitEachChildOfExportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportSpecifier(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.propertyName, visitor, isIdentifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[280 /* ExternalModuleReference */]: function visitEachChildOfExternalModuleReference(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExternalModuleReference(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[281 /* JsxElement */]: function visitEachChildOfJsxElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxElement(
|
|
node,
|
|
nodeVisitor(node.openingElement, visitor, isJsxOpeningElement),
|
|
nodesVisitor(node.children, visitor, isJsxChild),
|
|
nodeVisitor(node.closingElement, visitor, isJsxClosingElement)
|
|
);
|
|
},
|
|
[282 /* JsxSelfClosingElement */]: function visitEachChildOfJsxSelfClosingElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxSelfClosingElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
},
|
|
[283 /* JsxOpeningElement */]: function visitEachChildOfJsxOpeningElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxOpeningElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
},
|
|
[284 /* JsxClosingElement */]: function visitEachChildOfJsxClosingElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxClosingElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression)
|
|
);
|
|
},
|
|
[285 /* JsxFragment */]: function visitEachChildOfJsxFragment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxFragment(
|
|
node,
|
|
nodeVisitor(node.openingFragment, visitor, isJsxOpeningFragment),
|
|
nodesVisitor(node.children, visitor, isJsxChild),
|
|
nodeVisitor(node.closingFragment, visitor, isJsxClosingFragment)
|
|
);
|
|
},
|
|
[288 /* JsxAttribute */]: function visitEachChildOfJsxAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxAttribute(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.initializer, visitor, isStringLiteralOrJsxExpression)
|
|
);
|
|
},
|
|
[289 /* JsxAttributes */]: function visitEachChildOfJsxAttributes(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxAttributes(
|
|
node,
|
|
nodesVisitor(node.properties, visitor, isJsxAttributeLike)
|
|
);
|
|
},
|
|
[290 /* JsxSpreadAttribute */]: function visitEachChildOfJsxSpreadAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxSpreadAttribute(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[291 /* JsxExpression */]: function visitEachChildOfJsxExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[292 /* CaseClause */]: function visitEachChildOfCaseClause(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCaseClause(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[293 /* DefaultClause */]: function visitEachChildOfDefaultClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDefaultClause(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[294 /* HeritageClause */]: function visitEachChildOfHeritageClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateHeritageClause(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isExpressionWithTypeArguments)
|
|
);
|
|
},
|
|
[295 /* CatchClause */]: function visitEachChildOfCatchClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCatchClause(
|
|
node,
|
|
nodeVisitor(node.variableDeclaration, visitor, isVariableDeclaration),
|
|
nodeVisitor(node.block, visitor, isBlock)
|
|
);
|
|
},
|
|
[299 /* PropertyAssignment */]: function visitEachChildOfPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePropertyAssignment(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[300 /* ShorthandPropertyAssignment */]: function visitEachChildOfShorthandPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateShorthandPropertyAssignment(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.objectAssignmentInitializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[301 /* SpreadAssignment */]: function visitEachChildOfSpreadAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSpreadAssignment(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[302 /* EnumMember */]: function visitEachChildOfEnumMember(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateEnumMember(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[308 /* SourceFile */]: function visitEachChildOfSourceFile(node, visitor, context, _nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSourceFile(
|
|
node,
|
|
visitLexicalEnvironment(node.statements, visitor, context)
|
|
);
|
|
},
|
|
[353 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePartiallyEmittedExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[354 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCommaListExpression(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExpression)
|
|
);
|
|
}
|
|
};
|
|
function extractSingleNode(nodes) {
|
|
Debug.assert(nodes.length <= 1, "Too many nodes written to output.");
|
|
return singleOrUndefined(nodes);
|
|
}
|
|
|
|
// src/compiler/sourcemap.ts
|
|
function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
|
|
const { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
|
|
const rawSources = [];
|
|
const sources = [];
|
|
const sourceToSourceIndexMap = /* @__PURE__ */ new Map();
|
|
let sourcesContent;
|
|
const names = [];
|
|
let nameToNameIndexMap;
|
|
const mappingCharCodes = [];
|
|
let mappings = "";
|
|
let lastGeneratedLine = 0;
|
|
let lastGeneratedCharacter = 0;
|
|
let lastSourceIndex = 0;
|
|
let lastSourceLine = 0;
|
|
let lastSourceCharacter = 0;
|
|
let lastNameIndex = 0;
|
|
let hasLast = false;
|
|
let pendingGeneratedLine = 0;
|
|
let pendingGeneratedCharacter = 0;
|
|
let pendingSourceIndex = 0;
|
|
let pendingSourceLine = 0;
|
|
let pendingSourceCharacter = 0;
|
|
let pendingNameIndex = 0;
|
|
let hasPending = false;
|
|
let hasPendingSource = false;
|
|
let hasPendingName = false;
|
|
return {
|
|
getSources: () => rawSources,
|
|
addSource,
|
|
setSourceContent,
|
|
addName,
|
|
addMapping,
|
|
appendSourceMap,
|
|
toJSON,
|
|
toString: () => JSON.stringify(toJSON())
|
|
};
|
|
function addSource(fileName) {
|
|
enter();
|
|
const source = getRelativePathToDirectoryOrUrl(
|
|
sourcesDirectoryPath,
|
|
fileName,
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
true
|
|
);
|
|
let sourceIndex = sourceToSourceIndexMap.get(source);
|
|
if (sourceIndex === void 0) {
|
|
sourceIndex = sources.length;
|
|
sources.push(source);
|
|
rawSources.push(fileName);
|
|
sourceToSourceIndexMap.set(source, sourceIndex);
|
|
}
|
|
exit();
|
|
return sourceIndex;
|
|
}
|
|
function setSourceContent(sourceIndex, content) {
|
|
enter();
|
|
if (content !== null) {
|
|
if (!sourcesContent)
|
|
sourcesContent = [];
|
|
while (sourcesContent.length < sourceIndex) {
|
|
sourcesContent.push(null);
|
|
}
|
|
sourcesContent[sourceIndex] = content;
|
|
}
|
|
exit();
|
|
}
|
|
function addName(name) {
|
|
enter();
|
|
if (!nameToNameIndexMap)
|
|
nameToNameIndexMap = /* @__PURE__ */ new Map();
|
|
let nameIndex = nameToNameIndexMap.get(name);
|
|
if (nameIndex === void 0) {
|
|
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 !== void 0 && sourceLine !== void 0 && sourceCharacter !== void 0 && pendingSourceIndex === sourceIndex && (pendingSourceLine > sourceLine || pendingSourceLine === sourceLine && pendingSourceCharacter > sourceCharacter);
|
|
}
|
|
function addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, nameIndex) {
|
|
Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative");
|
|
Debug.assert(sourceIndex === void 0 || sourceIndex >= 0, "sourceIndex cannot be negative");
|
|
Debug.assert(sourceLine === void 0 || sourceLine >= 0, "sourceLine cannot be negative");
|
|
Debug.assert(sourceCharacter === void 0 || sourceCharacter >= 0, "sourceCharacter cannot be negative");
|
|
enter();
|
|
if (isNewGeneratedPosition(generatedLine, generatedCharacter) || isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter)) {
|
|
commitPendingMapping();
|
|
pendingGeneratedLine = generatedLine;
|
|
pendingGeneratedCharacter = generatedCharacter;
|
|
hasPendingSource = false;
|
|
hasPendingName = false;
|
|
hasPending = true;
|
|
}
|
|
if (sourceIndex !== void 0 && sourceLine !== void 0 && sourceCharacter !== void 0) {
|
|
pendingSourceIndex = sourceIndex;
|
|
pendingSourceLine = sourceLine;
|
|
pendingSourceCharacter = sourceCharacter;
|
|
hasPendingSource = true;
|
|
if (nameIndex !== void 0) {
|
|
pendingNameIndex = nameIndex;
|
|
hasPendingName = true;
|
|
}
|
|
}
|
|
exit();
|
|
}
|
|
function appendSourceMap(generatedLine, generatedCharacter, map2, sourceMapPath, start, end) {
|
|
Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative");
|
|
enter();
|
|
const sourceIndexToNewSourceIndexMap = [];
|
|
let nameIndexToNewNameIndexMap;
|
|
const mappingIterator = decodeMappings(map2.mappings);
|
|
for (let iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) {
|
|
const 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;
|
|
}
|
|
let newSourceIndex;
|
|
let newSourceLine;
|
|
let newSourceCharacter;
|
|
let newNameIndex;
|
|
if (raw.sourceIndex !== void 0) {
|
|
newSourceIndex = sourceIndexToNewSourceIndexMap[raw.sourceIndex];
|
|
if (newSourceIndex === void 0) {
|
|
const rawPath = map2.sources[raw.sourceIndex];
|
|
const relativePath = map2.sourceRoot ? combinePaths(map2.sourceRoot, rawPath) : rawPath;
|
|
const combinedPath = combinePaths(getDirectoryPath(sourceMapPath), relativePath);
|
|
sourceIndexToNewSourceIndexMap[raw.sourceIndex] = newSourceIndex = addSource(combinedPath);
|
|
if (map2.sourcesContent && typeof map2.sourcesContent[raw.sourceIndex] === "string") {
|
|
setSourceContent(newSourceIndex, map2.sourcesContent[raw.sourceIndex]);
|
|
}
|
|
}
|
|
newSourceLine = raw.sourceLine;
|
|
newSourceCharacter = raw.sourceCharacter;
|
|
if (map2.names && raw.nameIndex !== void 0) {
|
|
if (!nameIndexToNewNameIndexMap)
|
|
nameIndexToNewNameIndexMap = [];
|
|
newNameIndex = nameIndexToNewNameIndexMap[raw.nameIndex];
|
|
if (newNameIndex === void 0) {
|
|
nameIndexToNewNameIndexMap[raw.nameIndex] = newNameIndex = addName(map2.names[raw.nameIndex]);
|
|
}
|
|
}
|
|
}
|
|
const rawGeneratedLine = raw.generatedLine - (start ? start.line : 0);
|
|
const newGeneratedLine = rawGeneratedLine + generatedLine;
|
|
const rawGeneratedCharacter = start && start.line === raw.generatedLine ? raw.generatedCharacter - start.character : raw.generatedCharacter;
|
|
const 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);
|
|
if (mappingCharCodes.length >= 1024) {
|
|
flushMappingBuffer();
|
|
}
|
|
}
|
|
function commitPendingMapping() {
|
|
if (!hasPending || !shouldCommitMapping()) {
|
|
return;
|
|
}
|
|
enter();
|
|
if (lastGeneratedLine < pendingGeneratedLine) {
|
|
do {
|
|
appendMappingCharCode(59 /* semicolon */);
|
|
lastGeneratedLine++;
|
|
} while (lastGeneratedLine < pendingGeneratedLine);
|
|
lastGeneratedCharacter = 0;
|
|
} else {
|
|
Debug.assertEqual(lastGeneratedLine, pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
if (hasLast) {
|
|
appendMappingCharCode(44 /* comma */);
|
|
}
|
|
}
|
|
appendBase64VLQ(pendingGeneratedCharacter - lastGeneratedCharacter);
|
|
lastGeneratedCharacter = pendingGeneratedCharacter;
|
|
if (hasPendingSource) {
|
|
appendBase64VLQ(pendingSourceIndex - lastSourceIndex);
|
|
lastSourceIndex = pendingSourceIndex;
|
|
appendBase64VLQ(pendingSourceLine - lastSourceLine);
|
|
lastSourceLine = pendingSourceLine;
|
|
appendBase64VLQ(pendingSourceCharacter - lastSourceCharacter);
|
|
lastSourceCharacter = pendingSourceCharacter;
|
|
if (hasPendingName) {
|
|
appendBase64VLQ(pendingNameIndex - lastNameIndex);
|
|
lastNameIndex = pendingNameIndex;
|
|
}
|
|
}
|
|
hasLast = true;
|
|
exit();
|
|
}
|
|
function flushMappingBuffer() {
|
|
if (mappingCharCodes.length > 0) {
|
|
mappings += String.fromCharCode.apply(void 0, mappingCharCodes);
|
|
mappingCharCodes.length = 0;
|
|
}
|
|
}
|
|
function toJSON() {
|
|
commitPendingMapping();
|
|
flushMappingBuffer();
|
|
return {
|
|
version: 3,
|
|
file,
|
|
sourceRoot,
|
|
sources,
|
|
names,
|
|
mappings,
|
|
sourcesContent
|
|
};
|
|
}
|
|
function appendBase64VLQ(inValue) {
|
|
if (inValue < 0) {
|
|
inValue = (-inValue << 1) + 1;
|
|
} else {
|
|
inValue = inValue << 1;
|
|
}
|
|
do {
|
|
let currentDigit = inValue & 31;
|
|
inValue = inValue >> 5;
|
|
if (inValue > 0) {
|
|
currentDigit = currentDigit | 32;
|
|
}
|
|
appendMappingCharCode(base64FormatEncode(currentDigit));
|
|
} while (inValue > 0);
|
|
}
|
|
}
|
|
var sourceMapCommentRegExpDontCareLineStart = /\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
|
|
var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
|
|
var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
|
|
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" && isArray(x.sources) && every(x.sources, isString) && (x.sourceRoot === void 0 || x.sourceRoot === null || typeof x.sourceRoot === "string") && (x.sourcesContent === void 0 || x.sourcesContent === null || isArray(x.sourcesContent) && every(x.sourcesContent, isStringOrNull)) && (x.names === void 0 || x.names === null || isArray(x.names) && every(x.names, isString));
|
|
}
|
|
function tryParseRawSourceMap(text) {
|
|
try {
|
|
const parsed = JSON.parse(text);
|
|
if (isRawSourceMap(parsed)) {
|
|
return parsed;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return void 0;
|
|
}
|
|
function decodeMappings(mappings) {
|
|
let done = false;
|
|
let pos = 0;
|
|
let generatedLine = 0;
|
|
let generatedCharacter = 0;
|
|
let sourceIndex = 0;
|
|
let sourceLine = 0;
|
|
let sourceCharacter = 0;
|
|
let nameIndex = 0;
|
|
let error;
|
|
return {
|
|
get pos() {
|
|
return pos;
|
|
},
|
|
get error() {
|
|
return error;
|
|
},
|
|
get state() {
|
|
return captureMapping(true, true);
|
|
},
|
|
next() {
|
|
while (!done && pos < mappings.length) {
|
|
const ch = mappings.charCodeAt(pos);
|
|
if (ch === 59 /* semicolon */) {
|
|
generatedLine++;
|
|
generatedCharacter = 0;
|
|
pos++;
|
|
continue;
|
|
}
|
|
if (ch === 44 /* comma */) {
|
|
pos++;
|
|
continue;
|
|
}
|
|
let hasSource = false;
|
|
let 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 };
|
|
}
|
|
return stopIterating();
|
|
}
|
|
};
|
|
function captureMapping(hasSource, hasName) {
|
|
return {
|
|
generatedLine,
|
|
generatedCharacter,
|
|
sourceIndex: hasSource ? sourceIndex : void 0,
|
|
sourceLine: hasSource ? sourceLine : void 0,
|
|
sourceCharacter: hasSource ? sourceCharacter : void 0,
|
|
nameIndex: hasName ? nameIndex : void 0
|
|
};
|
|
}
|
|
function stopIterating() {
|
|
done = true;
|
|
return { value: void 0, done: true };
|
|
}
|
|
function setError(message) {
|
|
if (error === void 0) {
|
|
error = message;
|
|
}
|
|
}
|
|
function setErrorAndStopIterating(message) {
|
|
setError(message);
|
|
return stopIterating();
|
|
}
|
|
function hasReportedError() {
|
|
return error !== void 0;
|
|
}
|
|
function isSourceMappingSegmentEnd() {
|
|
return pos === mappings.length || mappings.charCodeAt(pos) === 44 /* comma */ || mappings.charCodeAt(pos) === 59 /* semicolon */;
|
|
}
|
|
function base64VLQFormatDecode() {
|
|
let moreDigits = true;
|
|
let shiftCount = 0;
|
|
let value = 0;
|
|
for (; moreDigits; pos++) {
|
|
if (pos >= mappings.length)
|
|
return setError("Error in decoding base64VLQFormatDecode, past the mapping string"), -1;
|
|
const currentByte = base64FormatDecode(mappings.charCodeAt(pos));
|
|
if (currentByte === -1)
|
|
return setError("Invalid character in VLQ"), -1;
|
|
moreDigits = (currentByte & 32) !== 0;
|
|
value = value | (currentByte & 31) << shiftCount;
|
|
shiftCount += 5;
|
|
}
|
|
if ((value & 1) === 0) {
|
|
value = value >> 1;
|
|
} else {
|
|
value = value >> 1;
|
|
value = -value;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
function base64FormatEncode(value) {
|
|
return value >= 0 && value < 26 ? 65 /* A */ + value : value >= 26 && value < 52 ? 97 /* a */ + value - 26 : value >= 52 && value < 62 ? 48 /* _0 */ + value - 52 : value === 62 ? 43 /* plus */ : value === 63 ? 47 /* slash */ : Debug.fail(`${value}: not a base64 value`);
|
|
}
|
|
function base64FormatDecode(ch) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ ? ch - 65 /* A */ : ch >= 97 /* a */ && ch <= 122 /* z */ ? ch - 97 /* a */ + 26 : ch >= 48 /* _0 */ && ch <= 57 /* _9 */ ? ch - 48 /* _0 */ + 52 : ch === 43 /* plus */ ? 62 : ch === 47 /* slash */ ? 63 : -1;
|
|
}
|
|
|
|
// src/compiler/transformers/utilities.ts
|
|
function getOriginalNodeId(node) {
|
|
node = getOriginalNode(node);
|
|
return node ? getNodeId(node) : 0;
|
|
}
|
|
function containsDefaultReference(node) {
|
|
if (!node)
|
|
return false;
|
|
if (!isNamedImports(node))
|
|
return false;
|
|
return some(node.elements, isNamedDefaultReference);
|
|
}
|
|
function isNamedDefaultReference(e) {
|
|
return e.propertyName !== void 0 && e.propertyName.escapedText === "default" /* Default */;
|
|
}
|
|
function chainBundle(context, transformSourceFile) {
|
|
return transformSourceFileOrBundle;
|
|
function transformSourceFileOrBundle(node) {
|
|
return node.kind === 308 /* SourceFile */ ? transformSourceFile(node) : transformBundle(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return context.factory.createBundle(map(node.sourceFiles, transformSourceFile), node.prepends);
|
|
}
|
|
}
|
|
function getExportNeedsImportStarHelper(node) {
|
|
return !!getNamespaceDeclarationNode(node);
|
|
}
|
|
function getImportNeedsImportStarHelper(node) {
|
|
if (!!getNamespaceDeclarationNode(node)) {
|
|
return true;
|
|
}
|
|
const bindings = node.importClause && node.importClause.namedBindings;
|
|
if (!bindings) {
|
|
return false;
|
|
}
|
|
if (!isNamedImports(bindings))
|
|
return false;
|
|
let defaultRefCount = 0;
|
|
for (const binding of bindings.elements) {
|
|
if (isNamedDefaultReference(binding)) {
|
|
defaultRefCount++;
|
|
}
|
|
}
|
|
return defaultRefCount > 0 && defaultRefCount !== bindings.elements.length || !!(bindings.elements.length - defaultRefCount) && isDefaultImport(node);
|
|
}
|
|
function getImportNeedsImportDefaultHelper(node) {
|
|
return !getImportNeedsImportStarHelper(node) && (isDefaultImport(node) || !!node.importClause && isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings));
|
|
}
|
|
function collectExternalModuleInfo(context, sourceFile, resolver, compilerOptions) {
|
|
const externalImports = [];
|
|
const exportSpecifiers = createMultiMap();
|
|
const exportedBindings = [];
|
|
const uniqueExports = /* @__PURE__ */ new Map();
|
|
let exportedNames;
|
|
let hasExportDefault = false;
|
|
let exportEquals;
|
|
let hasExportStarsToExportValues = false;
|
|
let hasImportStar = false;
|
|
let hasImportDefault = false;
|
|
for (const node of sourceFile.statements) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
externalImports.push(node);
|
|
if (!hasImportStar && getImportNeedsImportStarHelper(node)) {
|
|
hasImportStar = true;
|
|
}
|
|
if (!hasImportDefault && getImportNeedsImportDefaultHelper(node)) {
|
|
hasImportDefault = true;
|
|
}
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
externalImports.push(node);
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
if (node.moduleSpecifier) {
|
|
if (!node.exportClause) {
|
|
externalImports.push(node);
|
|
hasExportStarsToExportValues = true;
|
|
} else {
|
|
externalImports.push(node);
|
|
if (isNamedExports(node.exportClause)) {
|
|
addExportedNamesForExportDeclaration(node);
|
|
} else {
|
|
const name = node.exportClause.name;
|
|
if (!uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
hasImportStar = true;
|
|
}
|
|
}
|
|
} else {
|
|
addExportedNamesForExportDeclaration(node);
|
|
}
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
if (node.isExportEquals && !exportEquals) {
|
|
exportEquals = node;
|
|
}
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
for (const decl of node.declarationList.declarations) {
|
|
exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames);
|
|
}
|
|
}
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
if (hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
if (!hasExportDefault) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
|
|
hasExportDefault = true;
|
|
}
|
|
} else {
|
|
const name = node.name;
|
|
if (!uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
if (hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
if (!hasExportDefault) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
|
|
hasExportDefault = true;
|
|
}
|
|
} else {
|
|
const name = node.name;
|
|
if (name && !uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
const externalHelpersImportDeclaration = createExternalHelpersImportDeclarationIfNeeded(context.factory, context.getEmitHelperFactory(), sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault);
|
|
if (externalHelpersImportDeclaration) {
|
|
externalImports.unshift(externalHelpersImportDeclaration);
|
|
}
|
|
return { externalImports, exportSpecifiers, exportEquals, hasExportStarsToExportValues, exportedBindings, exportedNames, externalHelpersImportDeclaration };
|
|
function addExportedNamesForExportDeclaration(node) {
|
|
for (const specifier of cast(node.exportClause, isNamedExports).elements) {
|
|
if (!uniqueExports.get(idText(specifier.name))) {
|
|
const name = specifier.propertyName || specifier.name;
|
|
if (!node.moduleSpecifier) {
|
|
exportSpecifiers.add(idText(name), specifier);
|
|
}
|
|
const decl = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (decl) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
|
|
}
|
|
uniqueExports.set(idText(specifier.name), true);
|
|
exportedNames = append(exportedNames, specifier.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function collectExportedVariableInfo(decl, uniqueExports, exportedNames) {
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
exportedNames = collectExportedVariableInfo(element, uniqueExports, exportedNames);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
const text = idText(decl.name);
|
|
if (!uniqueExports.get(text)) {
|
|
uniqueExports.set(text, true);
|
|
exportedNames = append(exportedNames, decl.name);
|
|
}
|
|
}
|
|
return exportedNames;
|
|
}
|
|
function multiMapSparseArrayAdd(map2, key, value) {
|
|
let values = map2[key];
|
|
if (values) {
|
|
values.push(value);
|
|
} else {
|
|
map2[key] = values = [value];
|
|
}
|
|
return values;
|
|
}
|
|
function isSimpleCopiableExpression(expression) {
|
|
return isStringLiteralLike(expression) || expression.kind === 8 /* NumericLiteral */ || isKeyword(expression.kind) || isIdentifier(expression);
|
|
}
|
|
function isSimpleInlineableExpression(expression) {
|
|
return !isIdentifier(expression) && isSimpleCopiableExpression(expression);
|
|
}
|
|
function isCompoundAssignment(kind) {
|
|
return kind >= 64 /* FirstCompoundAssignment */ && kind <= 78 /* LastCompoundAssignment */;
|
|
}
|
|
function getNonAssignmentOperatorForCompoundAssignment(kind) {
|
|
switch (kind) {
|
|
case 64 /* PlusEqualsToken */:
|
|
return 39 /* PlusToken */;
|
|
case 65 /* MinusEqualsToken */:
|
|
return 40 /* MinusToken */;
|
|
case 66 /* AsteriskEqualsToken */:
|
|
return 41 /* AsteriskToken */;
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
return 42 /* AsteriskAsteriskToken */;
|
|
case 68 /* SlashEqualsToken */:
|
|
return 43 /* SlashToken */;
|
|
case 69 /* PercentEqualsToken */:
|
|
return 44 /* PercentToken */;
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
return 47 /* LessThanLessThanToken */;
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
return 48 /* GreaterThanGreaterThanToken */;
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
return 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
case 73 /* AmpersandEqualsToken */:
|
|
return 50 /* AmpersandToken */;
|
|
case 74 /* BarEqualsToken */:
|
|
return 51 /* BarToken */;
|
|
case 78 /* CaretEqualsToken */:
|
|
return 52 /* CaretToken */;
|
|
case 75 /* BarBarEqualsToken */:
|
|
return 56 /* BarBarToken */;
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
return 55 /* AmpersandAmpersandToken */;
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 60 /* QuestionQuestionToken */;
|
|
}
|
|
}
|
|
function getSuperCallFromStatement(statement) {
|
|
if (!isExpressionStatement(statement)) {
|
|
return void 0;
|
|
}
|
|
const expression = skipParentheses(statement.expression);
|
|
return isSuperCall(expression) ? expression : void 0;
|
|
}
|
|
function findSuperStatementIndex(statements, indexAfterLastPrologueStatement) {
|
|
for (let i = indexAfterLastPrologueStatement; i < statements.length; i += 1) {
|
|
const statement = statements[i];
|
|
if (getSuperCallFromStatement(statement)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function getProperties(node, requireInitializer, isStatic2) {
|
|
return filter(node.members, (m) => isInitializedOrStaticProperty(m, requireInitializer, isStatic2));
|
|
}
|
|
function isStaticPropertyDeclarationOrClassStaticBlockDeclaration(element) {
|
|
return isStaticPropertyDeclaration(element) || isClassStaticBlockDeclaration(element);
|
|
}
|
|
function getStaticPropertiesAndClassStaticBlock(node) {
|
|
return filter(node.members, isStaticPropertyDeclarationOrClassStaticBlockDeclaration);
|
|
}
|
|
function isInitializedOrStaticProperty(member, requireInitializer, isStatic2) {
|
|
return isPropertyDeclaration(member) && (!!member.initializer || !requireInitializer) && hasStaticModifier(member) === isStatic2;
|
|
}
|
|
function isStaticPropertyDeclaration(member) {
|
|
return isPropertyDeclaration(member) && hasStaticModifier(member);
|
|
}
|
|
function isInitializedProperty(member) {
|
|
return member.kind === 169 /* PropertyDeclaration */ && member.initializer !== void 0;
|
|
}
|
|
function isNonStaticMethodOrAccessorWithPrivateName(member) {
|
|
return !isStatic(member) && (isMethodOrAccessor(member) || isAutoAccessorPropertyDeclaration(member)) && isPrivateIdentifier(member.name);
|
|
}
|
|
function getDecoratorsOfParameters(node) {
|
|
let decorators;
|
|
if (node) {
|
|
const parameters = node.parameters;
|
|
const firstParameterIsThis = parameters.length > 0 && parameterIsThisKeyword(parameters[0]);
|
|
const firstParameterOffset = firstParameterIsThis ? 1 : 0;
|
|
const numParameters = firstParameterIsThis ? parameters.length - 1 : parameters.length;
|
|
for (let i = 0; i < numParameters; i++) {
|
|
const parameter = parameters[i + firstParameterOffset];
|
|
if (decorators || hasDecorators(parameter)) {
|
|
if (!decorators) {
|
|
decorators = new Array(numParameters);
|
|
}
|
|
decorators[i] = getDecorators(parameter);
|
|
}
|
|
}
|
|
}
|
|
return decorators;
|
|
}
|
|
function getAllDecoratorsOfClass(node) {
|
|
const decorators = getDecorators(node);
|
|
const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return {
|
|
decorators,
|
|
parameters
|
|
};
|
|
}
|
|
function getAllDecoratorsOfClassElement(member, parent) {
|
|
switch (member.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return getAllDecoratorsOfAccessors(member, parent);
|
|
case 171 /* MethodDeclaration */:
|
|
return getAllDecoratorsOfMethod(member);
|
|
case 169 /* PropertyDeclaration */:
|
|
return getAllDecoratorsOfProperty(member);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getAllDecoratorsOfAccessors(accessor, parent) {
|
|
if (!accessor.body) {
|
|
return void 0;
|
|
}
|
|
const { firstAccessor, secondAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(parent.members, accessor);
|
|
const firstAccessorWithDecorators = hasDecorators(firstAccessor) ? firstAccessor : secondAccessor && hasDecorators(secondAccessor) ? secondAccessor : void 0;
|
|
if (!firstAccessorWithDecorators || accessor !== firstAccessorWithDecorators) {
|
|
return void 0;
|
|
}
|
|
const decorators = getDecorators(firstAccessorWithDecorators);
|
|
const parameters = getDecoratorsOfParameters(setAccessor);
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return {
|
|
decorators,
|
|
parameters,
|
|
getDecorators: getAccessor && getDecorators(getAccessor),
|
|
setDecorators: setAccessor && getDecorators(setAccessor)
|
|
};
|
|
}
|
|
function getAllDecoratorsOfMethod(method) {
|
|
if (!method.body) {
|
|
return void 0;
|
|
}
|
|
const decorators = getDecorators(method);
|
|
const parameters = getDecoratorsOfParameters(method);
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return { decorators, parameters };
|
|
}
|
|
function getAllDecoratorsOfProperty(property) {
|
|
const decorators = getDecorators(property);
|
|
if (!some(decorators)) {
|
|
return void 0;
|
|
}
|
|
return { decorators };
|
|
}
|
|
|
|
// src/compiler/transformers/destructuring.ts
|
|
function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) {
|
|
let location = node;
|
|
let value;
|
|
if (isDestructuringAssignment(node)) {
|
|
value = node.right;
|
|
while (isEmptyArrayLiteral(node.left) || isEmptyObjectLiteral(node.left)) {
|
|
if (isDestructuringAssignment(value)) {
|
|
location = node = value;
|
|
value = node.right;
|
|
} else {
|
|
return visitNode(value, visitor, isExpression);
|
|
}
|
|
}
|
|
}
|
|
let expressions;
|
|
const flattenContext = {
|
|
context,
|
|
level,
|
|
downlevelIteration: !!context.getCompilerOptions().downlevelIteration,
|
|
hoistTempVariables: true,
|
|
emitExpression,
|
|
emitBindingOrAssignment,
|
|
createArrayBindingOrAssignmentPattern: (elements) => makeArrayAssignmentPattern(context.factory, elements),
|
|
createObjectBindingOrAssignmentPattern: (elements) => makeObjectAssignmentPattern(context.factory, elements),
|
|
createArrayBindingOrAssignmentElement: makeAssignmentElement,
|
|
visitor
|
|
};
|
|
if (value) {
|
|
value = visitNode(value, visitor, isExpression);
|
|
if (isIdentifier(value) && bindingOrAssignmentElementAssignsToName(node, value.escapedText) || bindingOrAssignmentElementContainsNonLiteralComputedName(node)) {
|
|
value = ensureIdentifier(flattenContext, value, false, location);
|
|
} else if (needsValue) {
|
|
value = ensureIdentifier(flattenContext, value, true, location);
|
|
} else if (nodeIsSynthesized(node)) {
|
|
location = value;
|
|
}
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, node, value, location, isDestructuringAssignment(node));
|
|
if (value && needsValue) {
|
|
if (!some(expressions)) {
|
|
return value;
|
|
}
|
|
expressions.push(value);
|
|
}
|
|
return context.factory.inlineExpressions(expressions) || context.factory.createOmittedExpression();
|
|
function emitExpression(expression) {
|
|
expressions = append(expressions, expression);
|
|
}
|
|
function emitBindingOrAssignment(target, value2, location2, original) {
|
|
Debug.assertNode(target, createAssignmentCallback ? isIdentifier : isExpression);
|
|
const expression = createAssignmentCallback ? createAssignmentCallback(target, value2, location2) : setTextRange(
|
|
context.factory.createAssignment(visitNode(target, visitor, isExpression), value2),
|
|
location2
|
|
);
|
|
expression.original = original;
|
|
emitExpression(expression);
|
|
}
|
|
}
|
|
function bindingOrAssignmentElementAssignsToName(element, escapedName) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (isBindingOrAssignmentPattern(target)) {
|
|
return bindingOrAssignmentPatternAssignsToName(target, escapedName);
|
|
} else if (isIdentifier(target)) {
|
|
return target.escapedText === escapedName;
|
|
}
|
|
return false;
|
|
}
|
|
function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
for (const element of elements) {
|
|
if (bindingOrAssignmentElementAssignsToName(element, escapedName)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function bindingOrAssignmentElementContainsNonLiteralComputedName(element) {
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (propertyName && isComputedPropertyName(propertyName) && !isLiteralExpression(propertyName.expression)) {
|
|
return true;
|
|
}
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
return !!target && isBindingOrAssignmentPattern(target) && bindingOrAssignmentPatternContainsNonLiteralComputedName(target);
|
|
}
|
|
function bindingOrAssignmentPatternContainsNonLiteralComputedName(pattern) {
|
|
return !!forEach(getElementsOfBindingOrAssignmentPattern(pattern), bindingOrAssignmentElementContainsNonLiteralComputedName);
|
|
}
|
|
function flattenDestructuringBinding(node, visitor, context, level, rval, hoistTempVariables = false, skipInitializer) {
|
|
let pendingExpressions;
|
|
const pendingDeclarations = [];
|
|
const declarations = [];
|
|
const flattenContext = {
|
|
context,
|
|
level,
|
|
downlevelIteration: !!context.getCompilerOptions().downlevelIteration,
|
|
hoistTempVariables,
|
|
emitExpression,
|
|
emitBindingOrAssignment,
|
|
createArrayBindingOrAssignmentPattern: (elements) => makeArrayBindingPattern(context.factory, elements),
|
|
createObjectBindingOrAssignmentPattern: (elements) => makeObjectBindingPattern(context.factory, elements),
|
|
createArrayBindingOrAssignmentElement: (name) => makeBindingElement(context.factory, name),
|
|
visitor
|
|
};
|
|
if (isVariableDeclaration(node)) {
|
|
let initializer = getInitializerOfBindingOrAssignmentElement(node);
|
|
if (initializer && (isIdentifier(initializer) && bindingOrAssignmentElementAssignsToName(node, initializer.escapedText) || bindingOrAssignmentElementContainsNonLiteralComputedName(node))) {
|
|
initializer = ensureIdentifier(flattenContext, visitNode(initializer, flattenContext.visitor), false, initializer);
|
|
node = context.factory.updateVariableDeclaration(node, node.name, void 0, void 0, initializer);
|
|
}
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, node, rval, node, skipInitializer);
|
|
if (pendingExpressions) {
|
|
const temp = context.factory.createTempVariable(void 0);
|
|
if (hoistTempVariables) {
|
|
const value = context.factory.inlineExpressions(pendingExpressions);
|
|
pendingExpressions = void 0;
|
|
emitBindingOrAssignment(temp, value, void 0, void 0);
|
|
} else {
|
|
context.hoistVariableDeclaration(temp);
|
|
const pendingDeclaration = last(pendingDeclarations);
|
|
pendingDeclaration.pendingExpressions = append(
|
|
pendingDeclaration.pendingExpressions,
|
|
context.factory.createAssignment(temp, pendingDeclaration.value)
|
|
);
|
|
addRange(pendingDeclaration.pendingExpressions, pendingExpressions);
|
|
pendingDeclaration.value = temp;
|
|
}
|
|
}
|
|
for (const { pendingExpressions: pendingExpressions2, name, value, location, original } of pendingDeclarations) {
|
|
const variable = context.factory.createVariableDeclaration(
|
|
name,
|
|
void 0,
|
|
void 0,
|
|
pendingExpressions2 ? context.factory.inlineExpressions(append(pendingExpressions2, value)) : value
|
|
);
|
|
variable.original = original;
|
|
setTextRange(variable, location);
|
|
declarations.push(variable);
|
|
}
|
|
return declarations;
|
|
function emitExpression(value) {
|
|
pendingExpressions = append(pendingExpressions, value);
|
|
}
|
|
function emitBindingOrAssignment(target, value, location, original) {
|
|
Debug.assertNode(target, isBindingName);
|
|
if (pendingExpressions) {
|
|
value = context.factory.inlineExpressions(append(pendingExpressions, value));
|
|
pendingExpressions = void 0;
|
|
}
|
|
pendingDeclarations.push({ pendingExpressions, name: target, value, location, original });
|
|
}
|
|
}
|
|
function flattenBindingOrAssignmentElement(flattenContext, element, value, location, skipInitializer) {
|
|
const bindingTarget = getTargetOfBindingOrAssignmentElement(element);
|
|
if (!skipInitializer) {
|
|
const initializer = visitNode(getInitializerOfBindingOrAssignmentElement(element), flattenContext.visitor, isExpression);
|
|
if (initializer) {
|
|
if (value) {
|
|
value = createDefaultValueCheck(flattenContext, value, initializer, location);
|
|
if (!isSimpleInlineableExpression(initializer) && isBindingOrAssignmentPattern(bindingTarget)) {
|
|
value = ensureIdentifier(flattenContext, value, true, location);
|
|
}
|
|
} else {
|
|
value = initializer;
|
|
}
|
|
} else if (!value) {
|
|
value = flattenContext.context.factory.createVoidZero();
|
|
}
|
|
}
|
|
if (isObjectBindingOrAssignmentPattern(bindingTarget)) {
|
|
flattenObjectBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location);
|
|
} else if (isArrayBindingOrAssignmentPattern(bindingTarget)) {
|
|
flattenArrayBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location);
|
|
} else {
|
|
flattenContext.emitBindingOrAssignment(bindingTarget, value, location, element);
|
|
}
|
|
}
|
|
function flattenObjectBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
const numElements = elements.length;
|
|
if (numElements !== 1) {
|
|
const reuseIdentifierExpressions = !isDeclarationBindingElement(parent) || numElements !== 0;
|
|
value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location);
|
|
}
|
|
let bindingElements;
|
|
let computedTempVariables;
|
|
for (let i = 0; i < numElements; i++) {
|
|
const element = elements[i];
|
|
if (!getRestIndicatorOfBindingOrAssignmentElement(element)) {
|
|
const propertyName = getPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (flattenContext.level >= 1 /* ObjectRest */ && !(element.transformFlags & (32768 /* ContainsRestOrSpread */ | 65536 /* ContainsObjectRestOrSpread */)) && !(getTargetOfBindingOrAssignmentElement(element).transformFlags & (32768 /* ContainsRestOrSpread */ | 65536 /* ContainsObjectRestOrSpread */)) && !isComputedPropertyName(propertyName)) {
|
|
bindingElements = append(bindingElements, visitNode(element, flattenContext.visitor));
|
|
} else {
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern);
|
|
bindingElements = void 0;
|
|
}
|
|
const rhsValue = createDestructuringPropertyAccess(flattenContext, value, propertyName);
|
|
if (isComputedPropertyName(propertyName)) {
|
|
computedTempVariables = append(computedTempVariables, rhsValue.argumentExpression);
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
} else if (i === numElements - 1) {
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern);
|
|
bindingElements = void 0;
|
|
}
|
|
const rhsValue = flattenContext.context.getEmitHelperFactory().createRestHelper(value, elements, computedTempVariables, pattern);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
}
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern);
|
|
}
|
|
}
|
|
function flattenArrayBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
const numElements = elements.length;
|
|
if (flattenContext.level < 1 /* ObjectRest */ && flattenContext.downlevelIteration) {
|
|
value = ensureIdentifier(
|
|
flattenContext,
|
|
setTextRange(
|
|
flattenContext.context.getEmitHelperFactory().createReadHelper(
|
|
value,
|
|
numElements > 0 && getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1]) ? void 0 : numElements
|
|
),
|
|
location
|
|
),
|
|
false,
|
|
location
|
|
);
|
|
} else if (numElements !== 1 && (flattenContext.level < 1 /* ObjectRest */ || numElements === 0) || every(elements, isOmittedExpression)) {
|
|
const reuseIdentifierExpressions = !isDeclarationBindingElement(parent) || numElements !== 0;
|
|
value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location);
|
|
}
|
|
let bindingElements;
|
|
let restContainingElements;
|
|
for (let i = 0; i < numElements; i++) {
|
|
const element = elements[i];
|
|
if (flattenContext.level >= 1 /* ObjectRest */) {
|
|
if (element.transformFlags & 65536 /* ContainsObjectRestOrSpread */ || flattenContext.hasTransformedPriorElement && !isSimpleBindingOrAssignmentElement(element)) {
|
|
flattenContext.hasTransformedPriorElement = true;
|
|
const temp = flattenContext.context.factory.createTempVariable(void 0);
|
|
if (flattenContext.hoistTempVariables) {
|
|
flattenContext.context.hoistVariableDeclaration(temp);
|
|
}
|
|
restContainingElements = append(restContainingElements, [temp, element]);
|
|
bindingElements = append(bindingElements, flattenContext.createArrayBindingOrAssignmentElement(temp));
|
|
} else {
|
|
bindingElements = append(bindingElements, element);
|
|
}
|
|
} else if (isOmittedExpression(element)) {
|
|
continue;
|
|
} else if (!getRestIndicatorOfBindingOrAssignmentElement(element)) {
|
|
const rhsValue = flattenContext.context.factory.createElementAccessExpression(value, i);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
} else if (i === numElements - 1) {
|
|
const rhsValue = flattenContext.context.factory.createArraySliceCall(value, i);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
}
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createArrayBindingOrAssignmentPattern(bindingElements), value, location, pattern);
|
|
}
|
|
if (restContainingElements) {
|
|
for (const [id, element] of restContainingElements) {
|
|
flattenBindingOrAssignmentElement(flattenContext, element, id, element);
|
|
}
|
|
}
|
|
}
|
|
function isSimpleBindingOrAssignmentElement(element) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (!target || isOmittedExpression(target))
|
|
return true;
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (propertyName && !isPropertyNameLiteral(propertyName))
|
|
return false;
|
|
const initializer = getInitializerOfBindingOrAssignmentElement(element);
|
|
if (initializer && !isSimpleInlineableExpression(initializer))
|
|
return false;
|
|
if (isBindingOrAssignmentPattern(target))
|
|
return every(getElementsOfBindingOrAssignmentPattern(target), isSimpleBindingOrAssignmentElement);
|
|
return isIdentifier(target);
|
|
}
|
|
function createDefaultValueCheck(flattenContext, value, defaultValue, location) {
|
|
value = ensureIdentifier(flattenContext, value, true, location);
|
|
return flattenContext.context.factory.createConditionalExpression(flattenContext.context.factory.createTypeCheck(value, "undefined"), void 0, defaultValue, void 0, value);
|
|
}
|
|
function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
|
|
if (isComputedPropertyName(propertyName)) {
|
|
const argumentExpression = ensureIdentifier(flattenContext, visitNode(propertyName.expression, flattenContext.visitor), false, propertyName);
|
|
return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
|
|
} else if (isStringOrNumericLiteralLike(propertyName)) {
|
|
const argumentExpression = factory.cloneNode(propertyName);
|
|
return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
|
|
} else {
|
|
const name = flattenContext.context.factory.createIdentifier(idText(propertyName));
|
|
return flattenContext.context.factory.createPropertyAccessExpression(value, name);
|
|
}
|
|
}
|
|
function ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location) {
|
|
if (isIdentifier(value) && reuseIdentifierExpressions) {
|
|
return value;
|
|
} else {
|
|
const temp = flattenContext.context.factory.createTempVariable(void 0);
|
|
if (flattenContext.hoistTempVariables) {
|
|
flattenContext.context.hoistVariableDeclaration(temp);
|
|
flattenContext.emitExpression(setTextRange(flattenContext.context.factory.createAssignment(temp, value), location));
|
|
} else {
|
|
flattenContext.emitBindingOrAssignment(temp, value, location, void 0);
|
|
}
|
|
return temp;
|
|
}
|
|
}
|
|
function makeArrayBindingPattern(factory2, elements) {
|
|
Debug.assertEachNode(elements, isArrayBindingElement);
|
|
return factory2.createArrayBindingPattern(elements);
|
|
}
|
|
function makeArrayAssignmentPattern(factory2, elements) {
|
|
return factory2.createArrayLiteralExpression(map(elements, factory2.converters.convertToArrayAssignmentElement));
|
|
}
|
|
function makeObjectBindingPattern(factory2, elements) {
|
|
Debug.assertEachNode(elements, isBindingElement);
|
|
return factory2.createObjectBindingPattern(elements);
|
|
}
|
|
function makeObjectAssignmentPattern(factory2, elements) {
|
|
return factory2.createObjectLiteralExpression(map(elements, factory2.converters.convertToObjectAssignmentElement));
|
|
}
|
|
function makeBindingElement(factory2, name) {
|
|
return factory2.createBindingElement(void 0, void 0, name);
|
|
}
|
|
function makeAssignmentElement(name) {
|
|
return name;
|
|
}
|
|
|
|
// src/compiler/transformers/taggedTemplate.ts
|
|
function processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, level) {
|
|
const tag = visitNode(node.tag, visitor, isExpression);
|
|
const templateArguments = [void 0];
|
|
const cookedStrings = [];
|
|
const rawStrings = [];
|
|
const template = node.template;
|
|
if (level === 0 /* LiftRestriction */ && !hasInvalidEscape(template)) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
if (isNoSubstitutionTemplateLiteral(template)) {
|
|
cookedStrings.push(createTemplateCooked(template));
|
|
rawStrings.push(getRawLiteral(template, currentSourceFile));
|
|
} else {
|
|
cookedStrings.push(createTemplateCooked(template.head));
|
|
rawStrings.push(getRawLiteral(template.head, currentSourceFile));
|
|
for (const templateSpan of template.templateSpans) {
|
|
cookedStrings.push(createTemplateCooked(templateSpan.literal));
|
|
rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile));
|
|
templateArguments.push(visitNode(templateSpan.expression, visitor, isExpression));
|
|
}
|
|
}
|
|
const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(
|
|
factory.createArrayLiteralExpression(cookedStrings),
|
|
factory.createArrayLiteralExpression(rawStrings)
|
|
);
|
|
if (isExternalModule(currentSourceFile)) {
|
|
const tempVar = factory.createUniqueName("templateObject");
|
|
recordTaggedTemplateString(tempVar);
|
|
templateArguments[0] = factory.createLogicalOr(
|
|
tempVar,
|
|
factory.createAssignment(
|
|
tempVar,
|
|
helperCall
|
|
)
|
|
);
|
|
} else {
|
|
templateArguments[0] = helperCall;
|
|
}
|
|
return factory.createCallExpression(tag, void 0, templateArguments);
|
|
}
|
|
function createTemplateCooked(template) {
|
|
return template.templateFlags ? factory.createVoidZero() : factory.createStringLiteral(template.text);
|
|
}
|
|
function getRawLiteral(node, currentSourceFile) {
|
|
let text = node.rawText;
|
|
if (text === void 0) {
|
|
Debug.assertIsDefined(
|
|
currentSourceFile,
|
|
"Template literal node is missing 'rawText' and does not have a source file. Possibly bad transform."
|
|
);
|
|
text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node);
|
|
const isLast = node.kind === 14 /* NoSubstitutionTemplateLiteral */ || node.kind === 17 /* TemplateTail */;
|
|
text = text.substring(1, text.length - (isLast ? 1 : 2));
|
|
}
|
|
text = text.replace(/\r\n?/g, "\n");
|
|
return setTextRange(factory.createStringLiteral(text), node);
|
|
}
|
|
|
|
// src/compiler/transformers/ts.ts
|
|
var USE_NEW_TYPE_METADATA_FORMAT = false;
|
|
function transformTypeScript(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const typeSerializer = compilerOptions.emitDecoratorMetadata ? createRuntimeTypeSerializer(context) : void 0;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
let currentSourceFile;
|
|
let currentNamespace;
|
|
let currentNamespaceContainerName;
|
|
let currentLexicalScope;
|
|
let currentScopeFirstDeclarationsOfName;
|
|
let currentClassHasParameterProperties;
|
|
let enabledSubstitutions;
|
|
let applicableSubstitutions;
|
|
return transformSourceFileOrBundle;
|
|
function transformSourceFileOrBundle(node) {
|
|
if (node.kind === 309 /* Bundle */) {
|
|
return transformBundle(node);
|
|
}
|
|
return transformSourceFile(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return factory2.createBundle(node.sourceFiles.map(transformSourceFile), mapDefined(node.prepends, (prepend) => {
|
|
if (prepend.kind === 311 /* InputFiles */) {
|
|
return createUnparsedSourceFile(prepend, "js");
|
|
}
|
|
return prepend;
|
|
}));
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const visited = saveStateAndInvoke(node, visitSourceFile);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
return visited;
|
|
}
|
|
function saveStateAndInvoke(node, f) {
|
|
const savedCurrentScope = currentLexicalScope;
|
|
const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
|
|
const savedCurrentClassHasParameterProperties = currentClassHasParameterProperties;
|
|
onBeforeVisitNode(node);
|
|
const visited = f(node);
|
|
if (currentLexicalScope !== savedCurrentScope) {
|
|
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
|
|
}
|
|
currentLexicalScope = savedCurrentScope;
|
|
currentClassHasParameterProperties = savedCurrentClassHasParameterProperties;
|
|
return visited;
|
|
}
|
|
function onBeforeVisitNode(node) {
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 266 /* CaseBlock */:
|
|
case 265 /* ModuleBlock */:
|
|
case 238 /* Block */:
|
|
currentLexicalScope = node;
|
|
currentScopeFirstDeclarationsOfName = void 0;
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
if (hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
break;
|
|
}
|
|
if (node.name) {
|
|
recordEmittedDeclarationInScope(node);
|
|
} else {
|
|
Debug.assert(node.kind === 260 /* ClassDeclaration */ || hasSyntacticModifier(node, 1024 /* Default */));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function visitor(node) {
|
|
return saveStateAndInvoke(node, visitorWorker);
|
|
}
|
|
function visitorWorker(node) {
|
|
if (node.transformFlags & 1 /* ContainsTypeScript */) {
|
|
return visitTypeScript(node);
|
|
}
|
|
return node;
|
|
}
|
|
function sourceElementVisitor(node) {
|
|
return saveStateAndInvoke(node, sourceElementVisitorWorker);
|
|
}
|
|
function sourceElementVisitorWorker(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 275 /* ExportDeclaration */:
|
|
return visitElidableStatement(node);
|
|
default:
|
|
return visitorWorker(node);
|
|
}
|
|
}
|
|
function visitElidableStatement(node) {
|
|
const parsed = getParseTreeNode(node);
|
|
if (parsed !== node) {
|
|
if (node.transformFlags & 1 /* ContainsTypeScript */) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
default:
|
|
Debug.fail("Unhandled ellided statement");
|
|
}
|
|
}
|
|
function namespaceElementVisitor(node) {
|
|
return saveStateAndInvoke(node, namespaceElementVisitorWorker);
|
|
}
|
|
function namespaceElementVisitorWorker(node) {
|
|
if (node.kind === 275 /* ExportDeclaration */ || node.kind === 269 /* ImportDeclaration */ || node.kind === 270 /* ImportClause */ || node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
return void 0;
|
|
} else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return visitTypeScript(node);
|
|
}
|
|
return node;
|
|
}
|
|
function getClassElementVisitor(parent) {
|
|
return (node) => saveStateAndInvoke(node, (n) => classElementVisitorWorker(n, parent));
|
|
}
|
|
function classElementVisitorWorker(node, parent) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return visitConstructor(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node, parent);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessor(node, parent);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessor(node, parent);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node, parent);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return visitEachChild(node, visitor, context);
|
|
case 237 /* SemicolonClassElement */:
|
|
return node;
|
|
case 178 /* IndexSignature */:
|
|
return;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function getObjectLiteralElementVisitor(parent) {
|
|
return (node) => saveStateAndInvoke(node, (n) => objectLiteralElementVisitorWorker(n, parent));
|
|
}
|
|
function objectLiteralElementVisitorWorker(node, parent) {
|
|
switch (node.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return visitor(node);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessor(node, parent);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessor(node, parent);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node, parent);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function modifierVisitor(node) {
|
|
if (isDecorator(node))
|
|
return void 0;
|
|
if (modifierToFlag(node.kind) & 117086 /* TypeScriptModifier */) {
|
|
return void 0;
|
|
} else if (currentNamespace && node.kind === 93 /* ExportKeyword */) {
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function visitTypeScript(node) {
|
|
if (isStatement(node) && hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return currentNamespace ? void 0 : node;
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
case 187 /* OptionalType */:
|
|
case 188 /* RestType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 179 /* TypePredicate */:
|
|
case 165 /* TypeParameter */:
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 182 /* ConstructorType */:
|
|
case 181 /* FunctionType */:
|
|
case 183 /* TypeQuery */:
|
|
case 180 /* TypeReference */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 191 /* ConditionalType */:
|
|
case 193 /* ParenthesizedType */:
|
|
case 194 /* ThisType */:
|
|
case 195 /* TypeOperator */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 197 /* MappedType */:
|
|
case 198 /* LiteralType */:
|
|
case 178 /* IndexSignature */:
|
|
return void 0;
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return factory2.createNotEmittedStatement(node);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return void 0;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return factory2.createNotEmittedStatement(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 294 /* HeritageClause */:
|
|
return visitHeritageClause(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return visitExpressionWithTypeArguments(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return Debug.fail("Class and object literal elements must be visited with their respective visitors");
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 216 /* ArrowFunction */:
|
|
return visitArrowFunction(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return visitAssertionExpression(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return visitSatisfiesExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 232 /* NonNullExpression */:
|
|
return visitNonNullExpression(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return visitEnumDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return visitModuleDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node);
|
|
case 283 /* JsxOpeningElement */:
|
|
return visitJsxJsxOpeningElement(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitSourceFile(node) {
|
|
const alwaysStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") && !(isExternalModule(node) && moduleKind >= 5 /* ES2015 */) && !isJsonSourceFile(node);
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
visitLexicalEnvironment(node.statements, sourceElementVisitor, context, 0, alwaysStrict)
|
|
);
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
return factory2.updateObjectLiteralExpression(
|
|
node,
|
|
visitNodes2(node.properties, getObjectLiteralElementVisitor(node), isObjectLiteralElement)
|
|
);
|
|
}
|
|
function getClassFacts(node, staticProperties) {
|
|
let facts = 0 /* None */;
|
|
if (some(staticProperties))
|
|
facts |= 1 /* HasStaticInitializedProperties */;
|
|
const extendsClauseElement = getEffectiveBaseTypeNode(node);
|
|
if (extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */)
|
|
facts |= 64 /* IsDerivedClass */;
|
|
if (classOrConstructorParameterIsDecorated(node))
|
|
facts |= 2 /* HasConstructorDecorators */;
|
|
if (childIsDecorated(node))
|
|
facts |= 4 /* HasMemberDecorators */;
|
|
if (isExportOfNamespace(node))
|
|
facts |= 8 /* IsExportOfNamespace */;
|
|
else if (isDefaultExternalModuleExport(node))
|
|
facts |= 32 /* IsDefaultExternalExport */;
|
|
else if (isNamedExternalModuleExport(node))
|
|
facts |= 16 /* IsNamedExternalExport */;
|
|
if (languageVersion <= 1 /* ES5 */ && facts & 7 /* MayNeedImmediatelyInvokedFunctionExpression */)
|
|
facts |= 128 /* UseImmediatelyInvokedFunctionExpression */;
|
|
return facts;
|
|
}
|
|
function hasTypeScriptClassSyntax(node) {
|
|
return !!(node.transformFlags & 8192 /* ContainsTypeScriptClassSyntax */);
|
|
}
|
|
function isClassLikeDeclarationWithTypeScriptSyntax(node) {
|
|
return hasDecorators(node) || some(node.typeParameters) || some(node.heritageClauses, hasTypeScriptClassSyntax) || some(node.members, hasTypeScriptClassSyntax);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && hasSyntacticModifier(node, 1 /* Export */))) {
|
|
return factory2.updateClassDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, getClassElementVisitor(node), isClassElement)
|
|
);
|
|
}
|
|
const staticProperties = getProperties(node, true, true);
|
|
const facts = getClassFacts(node, staticProperties);
|
|
if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */) {
|
|
context.startLexicalEnvironment();
|
|
}
|
|
const name = node.name || (facts & 5 /* NeedsName */ ? factory2.getGeneratedNameForNode(node) : void 0);
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators);
|
|
const modifiers = !(facts & 128 /* UseImmediatelyInvokedFunctionExpression */) ? visitNodes2(node.modifiers, modifierVisitor, isModifier) : elideNodes(factory2, node.modifiers);
|
|
const classStatement = factory2.updateClassDeclaration(
|
|
node,
|
|
concatenate(decorators, modifiers),
|
|
name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
transformClassMembers(node)
|
|
);
|
|
let emitFlags = getEmitFlags(node);
|
|
if (facts & 1 /* HasStaticInitializedProperties */) {
|
|
emitFlags |= 64 /* NoTrailingSourceMap */;
|
|
}
|
|
setEmitFlags(classStatement, emitFlags);
|
|
let statements = [classStatement];
|
|
if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */) {
|
|
const closingBraceLocation = createTokenRange(skipTrivia(currentSourceFile.text, node.members.end), 19 /* CloseBraceToken */);
|
|
const localName = factory2.getInternalName(node);
|
|
const outer = factory2.createPartiallyEmittedExpression(localName);
|
|
setTextRangeEnd(outer, closingBraceLocation.end);
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const statement = factory2.createReturnStatement(outer);
|
|
setTextRangePos(statement, closingBraceLocation.pos);
|
|
setEmitFlags(statement, 3072 /* NoComments */ | 768 /* NoTokenSourceMaps */);
|
|
statements.push(statement);
|
|
insertStatementsAfterStandardPrologue(statements, context.endLexicalEnvironment());
|
|
const iife = factory2.createImmediatelyInvokedArrowFunction(statements);
|
|
setEmitFlags(iife, 67108864 /* TypeScriptClassWrapper */);
|
|
const varStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, false, false),
|
|
void 0,
|
|
void 0,
|
|
iife
|
|
)
|
|
])
|
|
);
|
|
setOriginalNode(varStatement, node);
|
|
setCommentRange(varStatement, node);
|
|
setSourceMapRange(varStatement, moveRangePastDecorators(node));
|
|
startOnNewLine(varStatement);
|
|
statements = [varStatement];
|
|
}
|
|
if (facts & 8 /* IsExportOfNamespace */) {
|
|
addExportMemberAssignment(statements, node);
|
|
} else if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */ || facts & 2 /* HasConstructorDecorators */) {
|
|
if (facts & 32 /* IsDefaultExternalExport */) {
|
|
statements.push(factory2.createExportDefault(factory2.getLocalName(node, false, true)));
|
|
} else if (facts & 16 /* IsNamedExternalExport */) {
|
|
statements.push(factory2.createExternalModuleExport(factory2.getLocalName(node, false, true)));
|
|
}
|
|
}
|
|
if (statements.length > 1) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(classStatement, getEmitFlags(classStatement) | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassExpression(node) {
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators);
|
|
return factory2.updateClassExpression(
|
|
node,
|
|
decorators,
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
isClassLikeDeclarationWithTypeScriptSyntax(node) ? transformClassMembers(node) : visitNodes2(node.members, getClassElementVisitor(node), isClassElement)
|
|
);
|
|
}
|
|
function transformClassMembers(node) {
|
|
const members = [];
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
const parametersWithPropertyAssignments = constructor && filter(constructor.parameters, (p) => isParameterPropertyDeclaration(p, constructor));
|
|
if (parametersWithPropertyAssignments) {
|
|
for (const parameter of parametersWithPropertyAssignments) {
|
|
if (isIdentifier(parameter.name)) {
|
|
members.push(setOriginalNode(factory2.createPropertyDeclaration(
|
|
void 0,
|
|
parameter.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
), parameter));
|
|
}
|
|
}
|
|
}
|
|
addRange(members, visitNodes2(node.members, getClassElementVisitor(node), isClassElement));
|
|
return setTextRange(factory2.createNodeArray(members), node.members);
|
|
}
|
|
function transformAllDecoratorsOfDeclaration(node, container, allDecorators) {
|
|
var _a2, _b, _c, _d;
|
|
if (!allDecorators) {
|
|
return void 0;
|
|
}
|
|
const decorators = visitArray(allDecorators.decorators, visitor, isDecorator);
|
|
const parameterDecorators = flatMap(allDecorators.parameters, transformDecoratorsOfParameter);
|
|
const metadataDecorators = some(decorators) || some(parameterDecorators) ? getTypeMetadata(node, container) : void 0;
|
|
const result = factory2.createNodeArray(concatenate(concatenate(decorators, parameterDecorators), metadataDecorators));
|
|
const pos = (_b = (_a2 = firstOrUndefined(allDecorators.decorators)) == null ? void 0 : _a2.pos) != null ? _b : -1;
|
|
const end = (_d = (_c = lastOrUndefined(allDecorators.decorators)) == null ? void 0 : _c.end) != null ? _d : -1;
|
|
setTextRangePosEnd(result, pos, end);
|
|
return result;
|
|
}
|
|
function transformDecoratorsOfParameter(parameterDecorators, parameterOffset) {
|
|
if (parameterDecorators) {
|
|
const decorators = [];
|
|
for (const parameterDecorator of parameterDecorators) {
|
|
const expression = visitNode(parameterDecorator.expression, visitor, isExpression);
|
|
const helper = emitHelpers().createParamHelper(expression, parameterOffset);
|
|
setTextRange(helper, parameterDecorator.expression);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
const decorator = factory2.createDecorator(helper);
|
|
setSourceMapRange(decorator, parameterDecorator.expression);
|
|
setCommentRange(decorator, parameterDecorator.expression);
|
|
setEmitFlags(decorator, 3072 /* NoComments */);
|
|
decorators.push(decorator);
|
|
}
|
|
return decorators;
|
|
}
|
|
}
|
|
function getTypeMetadata(node, container) {
|
|
return USE_NEW_TYPE_METADATA_FORMAT ? getNewTypeMetadata(node, container) : getOldTypeMetadata(node, container);
|
|
}
|
|
function getOldTypeMetadata(node, container) {
|
|
if (typeSerializer) {
|
|
let decorators;
|
|
if (shouldAddTypeMetadata(node)) {
|
|
const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
|
|
decorators = append(decorators, factory2.createDecorator(typeMetadata));
|
|
}
|
|
if (shouldAddParamTypesMetadata(node)) {
|
|
const paramTypesMetadata = emitHelpers().createMetadataHelper("design:paramtypes", typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope, currentNameScope: container }, node, container));
|
|
decorators = append(decorators, factory2.createDecorator(paramTypesMetadata));
|
|
}
|
|
if (shouldAddReturnTypeMetadata(node)) {
|
|
const returnTypeMetadata = emitHelpers().createMetadataHelper("design:returntype", typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
|
|
decorators = append(decorators, factory2.createDecorator(returnTypeMetadata));
|
|
}
|
|
return decorators;
|
|
}
|
|
}
|
|
function getNewTypeMetadata(node, container) {
|
|
if (typeSerializer) {
|
|
let properties;
|
|
if (shouldAddTypeMetadata(node)) {
|
|
const typeProperty = factory2.createPropertyAssignment("type", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)));
|
|
properties = append(properties, typeProperty);
|
|
}
|
|
if (shouldAddParamTypesMetadata(node)) {
|
|
const paramTypeProperty = factory2.createPropertyAssignment("paramTypes", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope, currentNameScope: container }, node, container)));
|
|
properties = append(properties, paramTypeProperty);
|
|
}
|
|
if (shouldAddReturnTypeMetadata(node)) {
|
|
const returnTypeProperty = factory2.createPropertyAssignment("returnType", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)));
|
|
properties = append(properties, returnTypeProperty);
|
|
}
|
|
if (properties) {
|
|
const typeInfoMetadata = emitHelpers().createMetadataHelper("design:typeinfo", factory2.createObjectLiteralExpression(properties, true));
|
|
return [factory2.createDecorator(typeInfoMetadata)];
|
|
}
|
|
}
|
|
}
|
|
function shouldAddTypeMetadata(node) {
|
|
const kind = node.kind;
|
|
return kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 169 /* PropertyDeclaration */;
|
|
}
|
|
function shouldAddReturnTypeMetadata(node) {
|
|
return node.kind === 171 /* MethodDeclaration */;
|
|
}
|
|
function shouldAddParamTypesMetadata(node) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return getFirstConstructorWithBody(node) !== void 0;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
|
|
const name = member.name;
|
|
if (isPrivateIdentifier(name)) {
|
|
return factory2.createIdentifier("");
|
|
} else if (isComputedPropertyName(name)) {
|
|
return generateNameForComputedPropertyName && !isSimpleInlineableExpression(name.expression) ? factory2.getGeneratedNameForNode(name) : name.expression;
|
|
} else if (isIdentifier(name)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return factory2.cloneNode(name);
|
|
}
|
|
}
|
|
function visitPropertyNameOfClassElement(member) {
|
|
const name = member.name;
|
|
if (isComputedPropertyName(name) && (!hasStaticModifier(member) && currentClassHasParameterProperties || hasDecorators(member))) {
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const innerExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (!isSimpleInlineableExpression(innerExpression)) {
|
|
const generatedName = factory2.getGeneratedNameForNode(name);
|
|
hoistVariableDeclaration(generatedName);
|
|
return factory2.updateComputedPropertyName(name, factory2.createAssignment(generatedName, expression));
|
|
}
|
|
}
|
|
return visitNode(name, visitor, isPropertyName);
|
|
}
|
|
function visitHeritageClause(node) {
|
|
if (node.token === 117 /* ImplementsKeyword */) {
|
|
return void 0;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitExpressionWithTypeArguments(node) {
|
|
return factory2.updateExpressionWithTypeArguments(
|
|
node,
|
|
visitNode(node.expression, visitor, isLeftHandSideExpression),
|
|
void 0
|
|
);
|
|
}
|
|
function shouldEmitFunctionLikeDeclaration(node) {
|
|
return !nodeIsMissing(node.body);
|
|
}
|
|
function visitPropertyDeclaration(node, parent) {
|
|
const isAmbient = node.flags & 16777216 /* Ambient */ || hasSyntacticModifier(node, 256 /* Abstract */);
|
|
if (isAmbient && !hasDecorators(node)) {
|
|
return void 0;
|
|
}
|
|
const allDecorators = getAllDecoratorsOfClassElement(node, parent);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, parent, allDecorators);
|
|
if (isAmbient) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
concatenate(decorators, factory2.createModifiersFromModifierFlags(2 /* Ambient */)),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor)
|
|
);
|
|
}
|
|
function visitConstructor(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformConstructorBody(node.body, node)
|
|
);
|
|
}
|
|
function transformConstructorBody(body, constructor) {
|
|
const parametersWithPropertyAssignments = constructor && filter(constructor.parameters, (p) => isParameterPropertyDeclaration(p, constructor));
|
|
if (!some(parametersWithPropertyAssignments)) {
|
|
return visitFunctionBody(body, visitor, context);
|
|
}
|
|
let statements = [];
|
|
resumeLexicalEnvironment();
|
|
const prologueStatementCount = factory2.copyPrologue(body.statements, statements, false, visitor);
|
|
const superStatementIndex = findSuperStatementIndex(body.statements, prologueStatementCount);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(
|
|
statements,
|
|
visitNodes2(body.statements, visitor, isStatement, prologueStatementCount, superStatementIndex + 1 - prologueStatementCount)
|
|
);
|
|
}
|
|
const parameterPropertyAssignments = mapDefined(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(statements, parameterPropertyAssignments);
|
|
} else {
|
|
statements = [
|
|
...statements.slice(0, prologueStatementCount),
|
|
...parameterPropertyAssignments,
|
|
...statements.slice(prologueStatementCount)
|
|
];
|
|
}
|
|
const start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
|
|
addRange(statements, visitNodes2(body.statements, visitor, isStatement, start));
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), body.statements), true);
|
|
setTextRange(block, body);
|
|
setOriginalNode(block, body);
|
|
return block;
|
|
}
|
|
function transformParameterWithPropertyAssignment(node) {
|
|
const name = node.name;
|
|
if (!isIdentifier(name)) {
|
|
return void 0;
|
|
}
|
|
const propertyName = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setEmitFlags(propertyName, 3072 /* NoComments */ | 96 /* NoSourceMap */);
|
|
const localName = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setEmitFlags(localName, 3072 /* NoComments */);
|
|
return startOnNewLine(
|
|
removeAllComments(
|
|
setTextRange(
|
|
setOriginalNode(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
propertyName
|
|
),
|
|
node.name
|
|
),
|
|
localName
|
|
)
|
|
),
|
|
node
|
|
),
|
|
moveRangePos(node, -1)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function visitMethodDeclaration(node, parent) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const allDecorators = isClassLike(parent) ? getAllDecoratorsOfClassElement(node, parent) : void 0;
|
|
const decorators = isClassLike(parent) ? transformAllDecoratorsOfDeclaration(node, parent, allDecorators) : void 0;
|
|
return factory2.updateMethodDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
node.asteriskToken,
|
|
visitPropertyNameOfClassElement(node),
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function shouldEmitAccessorDeclaration(node) {
|
|
return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 256 /* Abstract */));
|
|
}
|
|
function visitGetAccessor(node, parent) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitAccessorDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const decorators = isClassLike(parent) ? transformAllDecoratorsOfDeclaration(node, parent, getAllDecoratorsOfClassElement(node, parent)) : void 0;
|
|
return factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
}
|
|
function visitSetAccessor(node, parent) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitAccessorDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const decorators = isClassLike(parent) ? transformAllDecoratorsOfDeclaration(node, parent, getAllDecoratorsOfClassElement(node, parent)) : void 0;
|
|
return factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
const updated = factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
if (isExportOfNamespace(node)) {
|
|
const statements = [updated];
|
|
addExportMemberAssignment(statements, node);
|
|
return statements;
|
|
}
|
|
return updated;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return factory2.createOmittedExpression();
|
|
}
|
|
const updated = factory2.updateFunctionExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
return updated;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
const updated = factory2.updateArrowFunction(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
return updated;
|
|
}
|
|
function visitParameter(node) {
|
|
if (parameterIsThisKeyword(node)) {
|
|
return void 0;
|
|
}
|
|
const updated = factory2.updateParameterDeclaration(
|
|
node,
|
|
elideNodes(factory2, node.modifiers),
|
|
node.dotDotDotToken,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (updated !== node) {
|
|
setCommentRange(updated, node);
|
|
setTextRange(updated, moveRangePastModifiers(node));
|
|
setSourceMapRange(updated, moveRangePastModifiers(node));
|
|
setEmitFlags(updated.name, 64 /* NoTrailingSourceMap */);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (isExportOfNamespace(node)) {
|
|
const variables = getInitializedVariables(node.declarationList);
|
|
if (variables.length === 0) {
|
|
return void 0;
|
|
}
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.inlineExpressions(
|
|
map(variables, transformInitializedVariable)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createNamespaceExportExpression
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
getNamespaceMemberNameWithSourceMapsAndWithoutComments(name),
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
const updated = factory2.updateVariableDeclaration(
|
|
node,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (node.type) {
|
|
setTypeNode(updated.name, node.type);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitParenthesizedExpression(node) {
|
|
const innerExpression = skipOuterExpressions(node.expression, ~6 /* Assertions */);
|
|
if (isAssertionExpression(innerExpression)) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitAssertionExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitNonNullExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isLeftHandSideExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitSatisfiesExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitCallExpression(node) {
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitNewExpression(node) {
|
|
return factory2.updateNewExpression(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
visitNode(node.tag, visitor, isExpression),
|
|
void 0,
|
|
visitNode(node.template, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitJsxSelfClosingElement(node) {
|
|
return factory2.updateJsxSelfClosingElement(
|
|
node,
|
|
visitNode(node.tagName, visitor, isJsxTagNameExpression),
|
|
void 0,
|
|
visitNode(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
}
|
|
function visitJsxJsxOpeningElement(node) {
|
|
return factory2.updateJsxOpeningElement(
|
|
node,
|
|
visitNode(node.tagName, visitor, isJsxTagNameExpression),
|
|
void 0,
|
|
visitNode(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
}
|
|
function shouldEmitEnumDeclaration(node) {
|
|
return !isEnumConst(node) || shouldPreserveConstEnums(compilerOptions);
|
|
}
|
|
function visitEnumDeclaration(node) {
|
|
if (!shouldEmitEnumDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
const statements = [];
|
|
let emitFlags = 4 /* AdviseOnEmitNode */;
|
|
const varAdded = addVarForEnumOrModuleDeclaration(statements, node);
|
|
if (varAdded) {
|
|
if (moduleKind !== 4 /* System */ || currentLexicalScope !== currentSourceFile) {
|
|
emitFlags |= 1024 /* NoLeadingComments */;
|
|
}
|
|
}
|
|
const parameterName = getNamespaceParameterName(node);
|
|
const containerName = getNamespaceContainerName(node);
|
|
const exportName = hasSyntacticModifier(node, 1 /* Export */) ? factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) : factory2.getLocalName(node, false, true);
|
|
let moduleArg = factory2.createLogicalOr(
|
|
exportName,
|
|
factory2.createAssignment(
|
|
exportName,
|
|
factory2.createObjectLiteralExpression()
|
|
)
|
|
);
|
|
if (hasNamespaceQualifiedExportName(node)) {
|
|
const localName = factory2.getLocalName(node, false, true);
|
|
moduleArg = factory2.createAssignment(localName, moduleArg);
|
|
}
|
|
const enumStatement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
transformEnumBody(node, containerName)
|
|
),
|
|
void 0,
|
|
[moduleArg]
|
|
)
|
|
);
|
|
setOriginalNode(enumStatement, node);
|
|
if (varAdded) {
|
|
setSyntheticLeadingComments(enumStatement, void 0);
|
|
setSyntheticTrailingComments(enumStatement, void 0);
|
|
}
|
|
setTextRange(enumStatement, node);
|
|
addEmitFlags(enumStatement, emitFlags);
|
|
statements.push(enumStatement);
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
return statements;
|
|
}
|
|
function transformEnumBody(node, localName) {
|
|
const savedCurrentNamespaceLocalName = currentNamespaceContainerName;
|
|
currentNamespaceContainerName = localName;
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const members = map(node.members, transformEnumMember);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
addRange(statements, members);
|
|
currentNamespaceContainerName = savedCurrentNamespaceLocalName;
|
|
return factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), node.members),
|
|
true
|
|
);
|
|
}
|
|
function transformEnumMember(member) {
|
|
const name = getExpressionForPropertyName(member, false);
|
|
const valueExpression = transformEnumMemberDeclarationValue(member);
|
|
const innerAssignment = factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
currentNamespaceContainerName,
|
|
name
|
|
),
|
|
valueExpression
|
|
);
|
|
const outerAssignment = valueExpression.kind === 10 /* StringLiteral */ ? innerAssignment : factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
currentNamespaceContainerName,
|
|
innerAssignment
|
|
),
|
|
name
|
|
);
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
setTextRange(
|
|
outerAssignment,
|
|
member
|
|
)
|
|
),
|
|
member
|
|
);
|
|
}
|
|
function transformEnumMemberDeclarationValue(member) {
|
|
const value = resolver.getConstantValue(member);
|
|
if (value !== void 0) {
|
|
return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
|
|
} else {
|
|
enableSubstitutionForNonQualifiedEnumMembers();
|
|
if (member.initializer) {
|
|
return visitNode(member.initializer, visitor, isExpression);
|
|
} else {
|
|
return factory2.createVoidZero();
|
|
}
|
|
}
|
|
}
|
|
function shouldEmitModuleDeclaration(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isModuleDeclaration);
|
|
if (!node) {
|
|
return true;
|
|
}
|
|
return isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions));
|
|
}
|
|
function hasNamespaceQualifiedExportName(node) {
|
|
return isExportOfNamespace(node) || isExternalModuleExport(node) && moduleKind !== 5 /* ES2015 */ && moduleKind !== 6 /* ES2020 */ && moduleKind !== 7 /* ES2022 */ && moduleKind !== 99 /* ESNext */ && moduleKind !== 4 /* System */;
|
|
}
|
|
function recordEmittedDeclarationInScope(node) {
|
|
if (!currentScopeFirstDeclarationsOfName) {
|
|
currentScopeFirstDeclarationsOfName = /* @__PURE__ */ new Map();
|
|
}
|
|
const name = declaredNameInScope(node);
|
|
if (!currentScopeFirstDeclarationsOfName.has(name)) {
|
|
currentScopeFirstDeclarationsOfName.set(name, node);
|
|
}
|
|
}
|
|
function isFirstEmittedDeclarationInScope(node) {
|
|
if (currentScopeFirstDeclarationsOfName) {
|
|
const name = declaredNameInScope(node);
|
|
return currentScopeFirstDeclarationsOfName.get(name) === node;
|
|
}
|
|
return true;
|
|
}
|
|
function declaredNameInScope(node) {
|
|
Debug.assertNode(node.name, isIdentifier);
|
|
return node.name.escapedText;
|
|
}
|
|
function addVarForEnumOrModuleDeclaration(statements, node) {
|
|
const statement = factory2.createVariableStatement(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, false, true)
|
|
)
|
|
], currentLexicalScope.kind === 308 /* SourceFile */ ? 0 /* None */ : 1 /* Let */)
|
|
);
|
|
setOriginalNode(statement, node);
|
|
recordEmittedDeclarationInScope(node);
|
|
if (isFirstEmittedDeclarationInScope(node)) {
|
|
if (node.kind === 263 /* EnumDeclaration */) {
|
|
setSourceMapRange(statement.declarationList, node);
|
|
} else {
|
|
setSourceMapRange(statement, node);
|
|
}
|
|
setCommentRange(statement, node);
|
|
addEmitFlags(statement, 2048 /* NoTrailingComments */ | 8388608 /* HasEndOfDeclarationMarker */);
|
|
statements.push(statement);
|
|
return true;
|
|
} else {
|
|
const mergeMarker = factory2.createMergeDeclarationMarker(statement);
|
|
setEmitFlags(mergeMarker, 3072 /* NoComments */ | 8388608 /* HasEndOfDeclarationMarker */);
|
|
statements.push(mergeMarker);
|
|
return false;
|
|
}
|
|
}
|
|
function visitModuleDeclaration(node) {
|
|
if (!shouldEmitModuleDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
Debug.assertNode(node.name, isIdentifier, "A TypeScript namespace should have an Identifier name.");
|
|
enableSubstitutionForNamespaceExports();
|
|
const statements = [];
|
|
let emitFlags = 4 /* AdviseOnEmitNode */;
|
|
const varAdded = addVarForEnumOrModuleDeclaration(statements, node);
|
|
if (varAdded) {
|
|
if (moduleKind !== 4 /* System */ || currentLexicalScope !== currentSourceFile) {
|
|
emitFlags |= 1024 /* NoLeadingComments */;
|
|
}
|
|
}
|
|
const parameterName = getNamespaceParameterName(node);
|
|
const containerName = getNamespaceContainerName(node);
|
|
const exportName = hasSyntacticModifier(node, 1 /* Export */) ? factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) : factory2.getLocalName(node, false, true);
|
|
let moduleArg = factory2.createLogicalOr(
|
|
exportName,
|
|
factory2.createAssignment(
|
|
exportName,
|
|
factory2.createObjectLiteralExpression()
|
|
)
|
|
);
|
|
if (hasNamespaceQualifiedExportName(node)) {
|
|
const localName = factory2.getLocalName(node, false, true);
|
|
moduleArg = factory2.createAssignment(localName, moduleArg);
|
|
}
|
|
const moduleStatement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
transformModuleBody(node, containerName)
|
|
),
|
|
void 0,
|
|
[moduleArg]
|
|
)
|
|
);
|
|
setOriginalNode(moduleStatement, node);
|
|
if (varAdded) {
|
|
setSyntheticLeadingComments(moduleStatement, void 0);
|
|
setSyntheticTrailingComments(moduleStatement, void 0);
|
|
}
|
|
setTextRange(moduleStatement, node);
|
|
addEmitFlags(moduleStatement, emitFlags);
|
|
statements.push(moduleStatement);
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
return statements;
|
|
}
|
|
function transformModuleBody(node, namespaceLocalName) {
|
|
const savedCurrentNamespaceContainerName = currentNamespaceContainerName;
|
|
const savedCurrentNamespace = currentNamespace;
|
|
const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
|
|
currentNamespaceContainerName = namespaceLocalName;
|
|
currentNamespace = node;
|
|
currentScopeFirstDeclarationsOfName = void 0;
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
let statementsLocation;
|
|
let blockLocation;
|
|
if (node.body) {
|
|
if (node.body.kind === 265 /* ModuleBlock */) {
|
|
saveStateAndInvoke(node.body, (body) => addRange(statements, visitNodes2(body.statements, namespaceElementVisitor, isStatement)));
|
|
statementsLocation = node.body.statements;
|
|
blockLocation = node.body;
|
|
} else {
|
|
const result = visitModuleDeclaration(node.body);
|
|
if (result) {
|
|
if (isArray(result)) {
|
|
addRange(statements, result);
|
|
} else {
|
|
statements.push(result);
|
|
}
|
|
}
|
|
const moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body;
|
|
statementsLocation = moveRangePos(moduleBlock.statements, -1);
|
|
}
|
|
}
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
currentNamespaceContainerName = savedCurrentNamespaceContainerName;
|
|
currentNamespace = savedCurrentNamespace;
|
|
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
|
|
const block = factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(statements),
|
|
statementsLocation
|
|
),
|
|
true
|
|
);
|
|
setTextRange(block, blockLocation);
|
|
if (!node.body || node.body.kind !== 265 /* ModuleBlock */) {
|
|
setEmitFlags(block, getEmitFlags(block) | 3072 /* NoComments */);
|
|
}
|
|
return block;
|
|
}
|
|
function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) {
|
|
if (moduleDeclaration.body.kind === 264 /* ModuleDeclaration */) {
|
|
const recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body);
|
|
return recursiveInnerModule || moduleDeclaration.body;
|
|
}
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
if (!node.importClause) {
|
|
return node;
|
|
}
|
|
if (node.importClause.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
const importClause = visitNode(node.importClause, visitImportClause, isImportClause);
|
|
return importClause || compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */ ? factory2.updateImportDeclaration(
|
|
node,
|
|
void 0,
|
|
importClause,
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
) : void 0;
|
|
}
|
|
function visitImportClause(node) {
|
|
Debug.assert(!node.isTypeOnly);
|
|
const name = shouldEmitAliasDeclaration(node) ? node.name : void 0;
|
|
const namedBindings = visitNode(node.namedBindings, visitNamedImportBindings, isNamedImportBindings);
|
|
return name || namedBindings ? factory2.updateImportClause(node, false, name, namedBindings) : void 0;
|
|
}
|
|
function visitNamedImportBindings(node) {
|
|
if (node.kind === 271 /* NamespaceImport */) {
|
|
return shouldEmitAliasDeclaration(node) ? node : void 0;
|
|
} else {
|
|
const allowEmpty = compilerOptions.preserveValueImports && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */);
|
|
const elements = visitNodes2(node.elements, visitImportSpecifier, isImportSpecifier);
|
|
return allowEmpty || some(elements) ? factory2.updateNamedImports(node, elements) : void 0;
|
|
}
|
|
}
|
|
function visitImportSpecifier(node) {
|
|
return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : void 0;
|
|
}
|
|
function visitExportAssignment(node) {
|
|
return resolver.isValueAliasDeclaration(node) ? visitEachChild(node, visitor, context) : void 0;
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (node.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
if (!node.exportClause || isNamespaceExport(node.exportClause)) {
|
|
return node;
|
|
}
|
|
const allowEmpty = !!node.moduleSpecifier && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */);
|
|
const exportClause = visitNode(
|
|
node.exportClause,
|
|
(bindings) => visitNamedExportBindings(bindings, allowEmpty),
|
|
isNamedExportBindings
|
|
);
|
|
return exportClause ? factory2.updateExportDeclaration(
|
|
node,
|
|
void 0,
|
|
node.isTypeOnly,
|
|
exportClause,
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
) : void 0;
|
|
}
|
|
function visitNamedExports(node, allowEmpty) {
|
|
const elements = visitNodes2(node.elements, visitExportSpecifier, isExportSpecifier);
|
|
return allowEmpty || some(elements) ? factory2.updateNamedExports(node, elements) : void 0;
|
|
}
|
|
function visitNamespaceExports(node) {
|
|
return factory2.updateNamespaceExport(node, visitNode(node.name, visitor, isIdentifier));
|
|
}
|
|
function visitNamedExportBindings(node, allowEmpty) {
|
|
return isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node, allowEmpty);
|
|
}
|
|
function visitExportSpecifier(node) {
|
|
return !node.isTypeOnly && resolver.isValueAliasDeclaration(node) ? node : void 0;
|
|
}
|
|
function shouldEmitImportEqualsDeclaration(node) {
|
|
return shouldEmitAliasDeclaration(node) || !isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
if (node.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
if (isExternalModuleImportEqualsDeclaration(node)) {
|
|
const isReferenced = shouldEmitAliasDeclaration(node);
|
|
if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1 /* Preserve */) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createImportDeclaration(
|
|
void 0,
|
|
void 0,
|
|
node.moduleReference.expression,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return isReferenced ? visitEachChild(node, visitor, context) : void 0;
|
|
}
|
|
if (!shouldEmitImportEqualsDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const moduleReference = createExpressionFromEntityName(factory2, node.moduleReference);
|
|
setEmitFlags(moduleReference, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
|
|
if (isNamedExternalModuleExport(node) || !isExportOfNamespace(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
factory2.createVariableDeclarationList([
|
|
setOriginalNode(
|
|
factory2.createVariableDeclaration(
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
moduleReference
|
|
),
|
|
node
|
|
)
|
|
])
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return setOriginalNode(
|
|
createNamespaceExport(
|
|
node.name,
|
|
moduleReference,
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function isExportOfNamespace(node) {
|
|
return currentNamespace !== void 0 && hasSyntacticModifier(node, 1 /* Export */);
|
|
}
|
|
function isExternalModuleExport(node) {
|
|
return currentNamespace === void 0 && hasSyntacticModifier(node, 1 /* Export */);
|
|
}
|
|
function isNamedExternalModuleExport(node) {
|
|
return isExternalModuleExport(node) && !hasSyntacticModifier(node, 1024 /* Default */);
|
|
}
|
|
function isDefaultExternalModuleExport(node) {
|
|
return isExternalModuleExport(node) && hasSyntacticModifier(node, 1024 /* Default */);
|
|
}
|
|
function addExportMemberAssignment(statements, node) {
|
|
const expression = factory2.createAssignment(
|
|
factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true),
|
|
factory2.getLocalName(node)
|
|
);
|
|
setSourceMapRange(expression, createRange(node.name ? node.name.pos : node.pos, node.end));
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
setSourceMapRange(statement, createRange(-1, node.end));
|
|
statements.push(statement);
|
|
}
|
|
function createNamespaceExport(exportName, exportValue, location) {
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.getNamespaceMemberName(currentNamespaceContainerName, exportName, false, true),
|
|
exportValue
|
|
)
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createNamespaceExportExpression(exportName, exportValue, location) {
|
|
return setTextRange(factory2.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location);
|
|
}
|
|
function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name) {
|
|
return factory2.getNamespaceMemberName(currentNamespaceContainerName, name, false, true);
|
|
}
|
|
function getNamespaceParameterName(node) {
|
|
const name = factory2.getGeneratedNameForNode(node);
|
|
setSourceMapRange(name, node.name);
|
|
return name;
|
|
}
|
|
function getNamespaceContainerName(node) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
function enableSubstitutionForNonQualifiedEnumMembers() {
|
|
if ((enabledSubstitutions & 8 /* NonQualifiedEnumMembers */) === 0) {
|
|
enabledSubstitutions |= 8 /* NonQualifiedEnumMembers */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
}
|
|
function enableSubstitutionForNamespaceExports() {
|
|
if ((enabledSubstitutions & 2 /* NamespaceExports */) === 0) {
|
|
enabledSubstitutions |= 2 /* NamespaceExports */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableEmitNotification(264 /* ModuleDeclaration */);
|
|
}
|
|
}
|
|
function isTransformedModuleDeclaration(node) {
|
|
return getOriginalNode(node).kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isTransformedEnumDeclaration(node) {
|
|
return getOriginalNode(node).kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
const savedApplicableSubstitutions = applicableSubstitutions;
|
|
const savedCurrentSourceFile = currentSourceFile;
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
}
|
|
if (enabledSubstitutions & 2 /* NamespaceExports */ && isTransformedModuleDeclaration(node)) {
|
|
applicableSubstitutions |= 2 /* NamespaceExports */;
|
|
}
|
|
if (enabledSubstitutions & 8 /* NonQualifiedEnumMembers */ && isTransformedEnumDeclaration(node)) {
|
|
applicableSubstitutions |= 8 /* NonQualifiedEnumMembers */;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
applicableSubstitutions = savedApplicableSubstitutions;
|
|
currentSourceFile = savedCurrentSourceFile;
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
if (enabledSubstitutions & 2 /* NamespaceExports */) {
|
|
const name = node.name;
|
|
const exportedName = trySubstituteNamespaceExportedName(name);
|
|
if (exportedName) {
|
|
if (node.objectAssignmentInitializer) {
|
|
const initializer = factory2.createAssignment(exportedName, node.objectAssignmentInitializer);
|
|
return setTextRange(factory2.createPropertyAssignment(name, initializer), node);
|
|
}
|
|
return setTextRange(factory2.createPropertyAssignment(name, exportedName), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
return trySubstituteNamespaceExportedName(node) || node;
|
|
}
|
|
function trySubstituteNamespaceExportedName(node) {
|
|
if (enabledSubstitutions & applicableSubstitutions && !isGeneratedIdentifier(node) && !isLocalName(node)) {
|
|
const container = resolver.getReferencedExportContainer(node, false);
|
|
if (container && container.kind !== 308 /* SourceFile */) {
|
|
const substitute = applicableSubstitutions & 2 /* NamespaceExports */ && container.kind === 264 /* ModuleDeclaration */ || applicableSubstitutions & 8 /* NonQualifiedEnumMembers */ && container.kind === 263 /* EnumDeclaration */;
|
|
if (substitute) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(factory2.getGeneratedNameForNode(container), node),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
return substituteConstantValue(node);
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
return substituteConstantValue(node);
|
|
}
|
|
function safeMultiLineComment(value) {
|
|
return value.replace(/\*\//g, "*_/");
|
|
}
|
|
function substituteConstantValue(node) {
|
|
const constantValue = tryGetConstEnumValue(node);
|
|
if (constantValue !== void 0) {
|
|
setConstantValue(node, constantValue);
|
|
const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : factory2.createNumericLiteral(constantValue);
|
|
if (!compilerOptions.removeComments) {
|
|
const originalNode = getOriginalNode(node, isAccessExpression);
|
|
addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, ` ${safeMultiLineComment(getTextOfNode(originalNode))} `);
|
|
}
|
|
return substitute;
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetConstEnumValue(node) {
|
|
if (compilerOptions.isolatedModules) {
|
|
return void 0;
|
|
}
|
|
return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : void 0;
|
|
}
|
|
function shouldEmitAliasDeclaration(node) {
|
|
return isInJSFile(node) || (compilerOptions.preserveValueImports ? resolver.isValueAliasDeclaration(node) : resolver.isReferencedAliasDeclaration(node));
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/classFields.ts
|
|
function transformClassFields(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration,
|
|
endLexicalEnvironment,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
addBlockScopedVariable
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
|
|
const shouldTransformInitializersUsingSet = !useDefineForClassFields;
|
|
const shouldTransformInitializersUsingDefine = useDefineForClassFields && languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformInitializers = shouldTransformInitializersUsingSet || shouldTransformInitializersUsingDefine;
|
|
const shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformAutoAccessors = languageVersion < 99 /* ESNext */;
|
|
const shouldTransformThisInStaticInitializers = languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2 /* ES2015 */;
|
|
const shouldTransformAnything = shouldTransformInitializers || shouldTransformPrivateElementsOrClassStaticBlocks || shouldTransformAutoAccessors;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
let enabledSubstitutions;
|
|
let classAliases;
|
|
let pendingExpressions;
|
|
let pendingStatements;
|
|
const classLexicalEnvironmentStack = [];
|
|
const classLexicalEnvironmentMap = /* @__PURE__ */ new Map();
|
|
let currentClassLexicalEnvironment;
|
|
let currentClassContainer;
|
|
let currentComputedPropertyNameClassLexicalEnvironment;
|
|
let currentStaticPropertyDeclarationOrStaticBlock;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !shouldTransformAnything) {
|
|
return node;
|
|
}
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
if (!(node.transformFlags & 16777216 /* ContainsClassFields */) && !(node.transformFlags & 134234112 /* ContainsLexicalThisOrSuper */)) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 127 /* AccessorKeyword */:
|
|
return shouldTransformAutoAccessors ? void 0 : node;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return visitClassStaticBlockDeclaration(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return visitPrivateIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return visitPropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitElementAccessExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, false);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, false);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */: {
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
fallbackVisitor,
|
|
node
|
|
);
|
|
}
|
|
default:
|
|
return fallbackVisitor(node);
|
|
}
|
|
}
|
|
function fallbackVisitor(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
switch (node.kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, true);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, true);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function heritageClauseVisitor(node) {
|
|
switch (node.kind) {
|
|
case 294 /* HeritageClause */:
|
|
return visitEachChild(node, heritageClauseVisitor, context);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return visitExpressionWithTypeArgumentsInHeritageClause(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function assignmentTargetVisitor(node) {
|
|
switch (node.kind) {
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitAssignmentPattern(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function classElementVisitor(node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return visitConstructorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
visitMethodOrAccessorDeclaration,
|
|
node
|
|
);
|
|
case 169 /* PropertyDeclaration */:
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
visitPropertyDeclaration,
|
|
node
|
|
);
|
|
case 164 /* ComputedPropertyName */:
|
|
return visitComputedPropertyName(node);
|
|
case 237 /* SemicolonClassElement */:
|
|
return node;
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function accessorFieldResultVisitor(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
return transformFieldInitializer(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return classElementVisitor(node);
|
|
default:
|
|
Debug.assertMissingNode(node, "Expected node to either be a PropertyDeclaration, GetAccessorDeclaration, or SetAccessorDeclaration");
|
|
break;
|
|
}
|
|
}
|
|
function visitPrivateIdentifier(node) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
return node;
|
|
}
|
|
if (isStatement(node.parent)) {
|
|
return node;
|
|
}
|
|
return setOriginalNode(factory2.createIdentifier(""), node);
|
|
}
|
|
function isPrivateIdentifierInExpression(node) {
|
|
return isPrivateIdentifier(node.left) && node.operatorToken.kind === 101 /* InKeyword */;
|
|
}
|
|
function transformPrivateIdentifierInInExpression(node) {
|
|
const info = accessPrivateIdentifier(node.left);
|
|
if (info) {
|
|
const receiver = visitNode(node.right, visitor, isExpression);
|
|
return setOriginalNode(
|
|
context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
const savedPendingStatements = pendingStatements;
|
|
pendingStatements = [];
|
|
const visitedNode = visitEachChild(node, visitor, context);
|
|
const statement = some(pendingStatements) ? [visitedNode, ...pendingStatements] : visitedNode;
|
|
pendingStatements = savedPendingStatements;
|
|
return statement;
|
|
}
|
|
function visitComputedPropertyName(node) {
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
if (some(pendingExpressions)) {
|
|
if (isParenthesizedExpression(expression)) {
|
|
expression = factory2.updateParenthesizedExpression(expression, factory2.inlineExpressions([...pendingExpressions, expression.expression]));
|
|
} else {
|
|
expression = factory2.inlineExpressions([...pendingExpressions, expression]);
|
|
}
|
|
pendingExpressions = void 0;
|
|
}
|
|
return factory2.updateComputedPropertyName(node, expression);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
if (currentClassContainer) {
|
|
return transformConstructor(node, currentClassContainer);
|
|
}
|
|
return fallbackVisitor(node);
|
|
}
|
|
function visitMethodOrAccessorDeclaration(node) {
|
|
Debug.assert(!hasDecorators(node));
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks || !isPrivateIdentifier(node.name)) {
|
|
return visitEachChild(node, classElementVisitor, context);
|
|
}
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
if (!info.isValid) {
|
|
return node;
|
|
}
|
|
const functionName = getHoistedFunctionName(node);
|
|
if (functionName) {
|
|
getPendingExpressions().push(
|
|
factory2.createAssignment(
|
|
functionName,
|
|
factory2.createFunctionExpression(
|
|
filter(node.modifiers, (m) => isModifier(m) && !isStaticModifier(m) && !isAccessorModifier(m)),
|
|
node.asteriskToken,
|
|
functionName,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
return void 0;
|
|
}
|
|
function setCurrentStaticPropertyDeclarationOrStaticBlockAnd(current, visitor2, arg) {
|
|
const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock;
|
|
currentStaticPropertyDeclarationOrStaticBlock = current;
|
|
const result = visitor2(arg);
|
|
currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock;
|
|
return result;
|
|
}
|
|
function getHoistedFunctionName(node) {
|
|
Debug.assert(isPrivateIdentifier(node.name));
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
if (info.kind === "m" /* Method */) {
|
|
return info.methodName;
|
|
}
|
|
if (info.kind === "a" /* Accessor */) {
|
|
if (isGetAccessor(node)) {
|
|
return info.getterName;
|
|
}
|
|
if (isSetAccessor(node)) {
|
|
return info.setterName;
|
|
}
|
|
}
|
|
}
|
|
function transformAutoAccessor(node) {
|
|
Debug.assertEachNode(node.modifiers, isModifier);
|
|
const commentRange = getCommentRange(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
const name = node.name;
|
|
let getterName = name;
|
|
let setterName = name;
|
|
if (isComputedPropertyName(name) && !isSimpleInlineableExpression(name.expression)) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setSourceMapRange(temp, name.expression);
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const assignment = factory2.createAssignment(temp, expression);
|
|
setSourceMapRange(assignment, name.expression);
|
|
getterName = factory2.updateComputedPropertyName(name, factory2.inlineExpressions([assignment, temp]));
|
|
setterName = factory2.updateComputedPropertyName(name, temp);
|
|
}
|
|
const backingField = createAccessorPropertyBackingField(factory2, node, node.modifiers, node.initializer);
|
|
setOriginalNode(backingField, node);
|
|
setEmitFlags(backingField, 3072 /* NoComments */);
|
|
setSourceMapRange(backingField, sourceMapRange);
|
|
const getter = createAccessorPropertyGetRedirector(factory2, node, node.modifiers, getterName);
|
|
setOriginalNode(getter, node);
|
|
setCommentRange(getter, commentRange);
|
|
setSourceMapRange(getter, sourceMapRange);
|
|
const setter = createAccessorPropertySetRedirector(factory2, node, node.modifiers, setterName);
|
|
setOriginalNode(setter, node);
|
|
setEmitFlags(setter, 3072 /* NoComments */);
|
|
setSourceMapRange(setter, sourceMapRange);
|
|
return visitArray([backingField, getter, setter], accessorFieldResultVisitor, isClassElement);
|
|
}
|
|
function transformPrivateFieldInitializer(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
return info.isValid ? void 0 : node;
|
|
}
|
|
if (shouldTransformInitializersUsingSet && !isStatic(node)) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformPublicFieldInitializer(node) {
|
|
if (shouldTransformInitializers) {
|
|
const expr = getPropertyNameExpressionIfNeeded(node.name, !!node.initializer || useDefineForClassFields);
|
|
if (expr) {
|
|
getPendingExpressions().push(expr);
|
|
}
|
|
if (isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const initializerStatement = transformPropertyOrClassStaticBlock(node, factory2.createThis());
|
|
if (initializerStatement) {
|
|
const staticBlock = factory2.createClassStaticBlockDeclaration(
|
|
factory2.createBlock([initializerStatement])
|
|
);
|
|
setOriginalNode(staticBlock, node);
|
|
setCommentRange(staticBlock, node);
|
|
setCommentRange(initializerStatement, { pos: -1, end: -1 });
|
|
setSyntheticLeadingComments(initializerStatement, void 0);
|
|
setSyntheticTrailingComments(initializerStatement, void 0);
|
|
return staticBlock;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
return visitEachChild(node, classElementVisitor, context);
|
|
}
|
|
function transformFieldInitializer(node) {
|
|
Debug.assert(!hasDecorators(node), "Decorators should already have been transformed and elided.");
|
|
return isPrivateIdentifierClassElementDeclaration(node) ? transformPrivateFieldInitializer(node) : transformPublicFieldInitializer(node);
|
|
}
|
|
function visitPropertyDeclaration(node) {
|
|
if (shouldTransformAutoAccessors && isAutoAccessorPropertyDeclaration(node)) {
|
|
return transformAutoAccessor(node);
|
|
}
|
|
return transformFieldInitializer(node);
|
|
}
|
|
function createPrivateIdentifierAccess(info, receiver) {
|
|
return createPrivateIdentifierAccessHelper(info, visitNode(receiver, visitor, isExpression));
|
|
}
|
|
function createPrivateIdentifierAccessHelper(info, receiver) {
|
|
setCommentRange(receiver, moveRangePos(receiver, -1));
|
|
switch (info.kind) {
|
|
case "a" /* Accessor */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.getterName
|
|
);
|
|
case "m" /* Method */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.methodName
|
|
);
|
|
case "f" /* Field */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.variableName
|
|
);
|
|
default:
|
|
Debug.assertNever(info, "Unknown private element type");
|
|
}
|
|
}
|
|
function visitPropertyAccessExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifier(node.name)) {
|
|
const privateIdentifierInfo = accessPrivateIdentifier(node.name);
|
|
if (privateIdentifierInfo) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
createPrivateIdentifierAccess(privateIdentifierInfo, node.expression),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node) && isIdentifier(node.name) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return visitInvalidSuperProperty(node);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
const superProperty = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
factory2.createStringLiteralFromNode(node.name),
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superProperty, node.expression);
|
|
setTextRange(superProperty, node.expression);
|
|
return superProperty;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitElementAccessExpression(node) {
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return visitInvalidSuperProperty(node);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
const superProperty = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
visitNode(node.argumentExpression, visitor, isExpression),
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superProperty, node.expression);
|
|
setTextRange(superProperty, node.expression);
|
|
return superProperty;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
const operand = skipParentheses(node.operand);
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(operand)) {
|
|
let info;
|
|
if (info = accessPrivateIdentifier(operand.name)) {
|
|
const receiver = visitNode(operand.expression, visitor, isExpression);
|
|
const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver);
|
|
let expression = createPrivateIdentifierAccess(info, readExpression);
|
|
const temp = isPrefixUnaryExpression(node) || valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, hoistVariableDeclaration, temp);
|
|
expression = createPrivateIdentifierAssignment(
|
|
info,
|
|
initializeExpression || readExpression,
|
|
expression,
|
|
63 /* EqualsToken */
|
|
);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(operand) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
const expression = visitInvalidSuperProperty(operand);
|
|
return isPrefixUnaryExpression(node) ? factory2.updatePrefixUnaryExpression(node, expression) : factory2.updatePostfixUnaryExpression(node, expression);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
let setterName;
|
|
let getterName;
|
|
if (isPropertyAccessExpression(operand)) {
|
|
if (isIdentifier(operand.name)) {
|
|
getterName = setterName = factory2.createStringLiteralFromNode(operand.name);
|
|
}
|
|
} else {
|
|
if (isSimpleInlineableExpression(operand.argumentExpression)) {
|
|
getterName = setterName = operand.argumentExpression;
|
|
} else {
|
|
getterName = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setterName = factory2.createAssignment(getterName, visitNode(operand.argumentExpression, visitor, isExpression));
|
|
}
|
|
}
|
|
if (setterName && getterName) {
|
|
let expression = factory2.createReflectGetCall(superClassReference, getterName, classConstructor);
|
|
setTextRange(expression, operand);
|
|
const temp = valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, hoistVariableDeclaration, temp);
|
|
expression = factory2.createReflectSetCall(superClassReference, setterName, expression, classConstructor);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(
|
|
node,
|
|
visitNode(node.expression, discardedValueVisitor, isExpression)
|
|
);
|
|
}
|
|
function createCopiableReceiverExpr(receiver) {
|
|
const clone2 = nodeIsSynthesized(receiver) ? receiver : factory2.cloneNode(receiver);
|
|
if (isSimpleInlineableExpression(receiver)) {
|
|
return { readExpression: clone2, initializeExpression: void 0 };
|
|
}
|
|
const readExpression = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const initializeExpression = factory2.createAssignment(readExpression, clone2);
|
|
return { readExpression, initializeExpression };
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.expression)) {
|
|
const { thisArg, target } = factory2.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion);
|
|
if (isCallChain(node)) {
|
|
return factory2.updateCallChain(
|
|
node,
|
|
factory2.createPropertyAccessChain(visitNode(target, visitor), node.questionDotToken, "call"),
|
|
void 0,
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression), ...visitNodes2(node.arguments, visitor, isExpression)]
|
|
);
|
|
}
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
factory2.createPropertyAccessExpression(visitNode(target, visitor), "call"),
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression), ...visitNodes2(node.arguments, visitor, isExpression)]
|
|
);
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.expression) && currentStaticPropertyDeclarationOrStaticBlock && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.classConstructor)) {
|
|
const invocation = factory2.createFunctionCallCall(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
currentClassLexicalEnvironment.classConstructor,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
setOriginalNode(invocation, node);
|
|
setTextRange(invocation, node);
|
|
return invocation;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.tag)) {
|
|
const { thisArg, target } = factory2.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion);
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(visitNode(target, visitor), "bind"),
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression)]
|
|
),
|
|
void 0,
|
|
visitNode(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.tag) && currentStaticPropertyDeclarationOrStaticBlock && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.classConstructor)) {
|
|
const invocation = factory2.createFunctionBindCall(
|
|
visitNode(node.tag, visitor, isExpression),
|
|
currentClassLexicalEnvironment.classConstructor,
|
|
[]
|
|
);
|
|
setOriginalNode(invocation, node);
|
|
setTextRange(invocation, node);
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
invocation,
|
|
void 0,
|
|
visitNode(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformClassStaticBlockDeclaration(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
if (currentClassLexicalEnvironment) {
|
|
classLexicalEnvironmentMap.set(getOriginalNodeId(node), currentClassLexicalEnvironment);
|
|
}
|
|
startLexicalEnvironment();
|
|
let statements = setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
node,
|
|
(statements2) => visitNodes2(statements2, visitor, isStatement),
|
|
node.body.statements
|
|
);
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
const iife = factory2.createImmediatelyInvokedArrowFunction(statements);
|
|
setOriginalNode(iife, node);
|
|
setTextRange(iife, node);
|
|
addEmitFlags(iife, 4 /* AdviseOnEmitNode */);
|
|
return iife;
|
|
}
|
|
}
|
|
function visitBinaryExpression(node, valueIsDiscarded) {
|
|
if (isDestructuringAssignment(node)) {
|
|
const savedPendingExpressions = pendingExpressions;
|
|
pendingExpressions = void 0;
|
|
node = factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, assignmentTargetVisitor),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor)
|
|
);
|
|
const expr = some(pendingExpressions) ? factory2.inlineExpressions(compact([...pendingExpressions, node])) : node;
|
|
pendingExpressions = savedPendingExpressions;
|
|
return expr;
|
|
}
|
|
if (isAssignmentExpression(node)) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.left)) {
|
|
const info = accessPrivateIdentifier(node.left.name);
|
|
if (info) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
createPrivateIdentifierAssignment(info, node.left.expression, node.right, node.operatorToken.kind),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.left) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitInvalidSuperProperty(node.left),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
let setterName = isElementAccessExpression(node.left) ? visitNode(node.left.argumentExpression, visitor, isExpression) : isIdentifier(node.left.name) ? factory2.createStringLiteralFromNode(node.left.name) : void 0;
|
|
if (setterName) {
|
|
let expression = visitNode(node.right, visitor, isExpression);
|
|
if (isCompoundAssignment(node.operatorToken.kind)) {
|
|
let getterName = setterName;
|
|
if (!isSimpleInlineableExpression(setterName)) {
|
|
getterName = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setterName = factory2.createAssignment(getterName, setterName);
|
|
}
|
|
const superPropertyGet = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
getterName,
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superPropertyGet, node.left);
|
|
setTextRange(superPropertyGet, node.left);
|
|
expression = factory2.createBinaryExpression(
|
|
superPropertyGet,
|
|
getNonAssignmentOperatorForCompoundAssignment(node.operatorToken.kind),
|
|
expression
|
|
);
|
|
setTextRange(expression, node);
|
|
}
|
|
const temp = valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
if (temp) {
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(temp, node);
|
|
}
|
|
expression = factory2.createReflectSetCall(
|
|
superClassReference,
|
|
setterName,
|
|
expression,
|
|
classConstructor
|
|
);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierInExpression(node)) {
|
|
return transformPrivateIdentifierInInExpression(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function createPrivateIdentifierAssignment(info, receiver, right, operator) {
|
|
receiver = visitNode(receiver, visitor, isExpression);
|
|
right = visitNode(right, visitor, isExpression);
|
|
if (isCompoundAssignment(operator)) {
|
|
const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver);
|
|
receiver = initializeExpression || readExpression;
|
|
right = factory2.createBinaryExpression(
|
|
createPrivateIdentifierAccessHelper(info, readExpression),
|
|
getNonAssignmentOperatorForCompoundAssignment(operator),
|
|
right
|
|
);
|
|
}
|
|
setCommentRange(receiver, moveRangePos(receiver, -1));
|
|
switch (info.kind) {
|
|
case "a" /* Accessor */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
info.setterName
|
|
);
|
|
case "m" /* Method */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
void 0
|
|
);
|
|
case "f" /* Field */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
info.variableName
|
|
);
|
|
default:
|
|
Debug.assertNever(info, "Unknown private element type");
|
|
}
|
|
}
|
|
function getPrivateInstanceMethodsAndAccessors(node) {
|
|
return filter(node.members, isNonStaticMethodOrAccessorWithPrivateName);
|
|
}
|
|
function getClassFacts(node) {
|
|
let facts = 0 /* None */;
|
|
const original = getOriginalNode(node);
|
|
if (isClassDeclaration(original) && classOrConstructorParameterIsDecorated(original)) {
|
|
facts |= 1 /* ClassWasDecorated */;
|
|
}
|
|
for (const member of node.members) {
|
|
if (!isStatic(member))
|
|
continue;
|
|
if (member.name && (isPrivateIdentifier(member.name) || isAutoAccessorPropertyDeclaration(member)) && shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
facts |= 2 /* NeedsClassConstructorReference */;
|
|
}
|
|
if (isPropertyDeclaration(member) || isClassStaticBlockDeclaration(member)) {
|
|
if (shouldTransformThisInStaticInitializers && member.transformFlags & 16384 /* ContainsLexicalThis */) {
|
|
facts |= 8 /* NeedsSubstitutionForThisInClassStaticField */;
|
|
if (!(facts & 1 /* ClassWasDecorated */)) {
|
|
facts |= 2 /* NeedsClassConstructorReference */;
|
|
}
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && member.transformFlags & 134217728 /* ContainsLexicalSuper */) {
|
|
if (!(facts & 1 /* ClassWasDecorated */)) {
|
|
facts |= 2 /* NeedsClassConstructorReference */ | 4 /* NeedsClassSuperReference */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return facts;
|
|
}
|
|
function visitExpressionWithTypeArgumentsInHeritageClause(node) {
|
|
const facts = (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.facts) || 0 /* None */;
|
|
if (facts & 4 /* NeedsClassSuperReference */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getClassLexicalEnvironment().superClassReference = temp;
|
|
return factory2.updateExpressionWithTypeArguments(
|
|
node,
|
|
factory2.createAssignment(
|
|
temp,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
),
|
|
void 0
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitInNewClassLexicalEnvironment(node, visitor2) {
|
|
const savedCurrentClassContainer = currentClassContainer;
|
|
const savedPendingExpressions = pendingExpressions;
|
|
currentClassContainer = node;
|
|
pendingExpressions = void 0;
|
|
startClassLexicalEnvironment();
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const name = getNameOfDeclaration(node);
|
|
if (name && isIdentifier(name)) {
|
|
getPrivateIdentifierEnvironment().className = name;
|
|
}
|
|
const privateInstanceMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
|
|
if (some(privateInstanceMethodsAndAccessors)) {
|
|
getPrivateIdentifierEnvironment().weakSetName = createHoistedVariableForClass(
|
|
"instances",
|
|
privateInstanceMethodsAndAccessors[0].name
|
|
);
|
|
}
|
|
}
|
|
const facts = getClassFacts(node);
|
|
if (facts) {
|
|
getClassLexicalEnvironment().facts = facts;
|
|
}
|
|
if (facts & 8 /* NeedsSubstitutionForThisInClassStaticField */) {
|
|
enableSubstitutionForClassStaticThisOrSuperReference();
|
|
}
|
|
const result = visitor2(node, facts);
|
|
endClassLexicalEnvironment();
|
|
currentClassContainer = savedCurrentClassContainer;
|
|
pendingExpressions = savedPendingExpressions;
|
|
return result;
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
return visitInNewClassLexicalEnvironment(node, visitClassDeclarationInNewClassLexicalEnvironment);
|
|
}
|
|
function visitClassDeclarationInNewClassLexicalEnvironment(node, facts) {
|
|
let pendingClassReferenceAssignment;
|
|
if (facts & 2 /* NeedsClassConstructorReference */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getClassLexicalEnvironment().classConstructor = factory2.cloneNode(temp);
|
|
pendingClassReferenceAssignment = factory2.createAssignment(temp, factory2.getInternalName(node));
|
|
}
|
|
const modifiers = visitNodes2(node.modifiers, visitor, isModifierLike);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
|
|
const { members, prologue } = transformClassMembers(node);
|
|
const classDecl = factory2.updateClassDeclaration(
|
|
node,
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
const statements = [];
|
|
if (prologue) {
|
|
statements.push(factory2.createExpressionStatement(prologue));
|
|
}
|
|
statements.push(classDecl);
|
|
if (pendingClassReferenceAssignment) {
|
|
getPendingExpressions().unshift(pendingClassReferenceAssignment);
|
|
}
|
|
if (some(pendingExpressions)) {
|
|
statements.push(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
}
|
|
if (shouldTransformInitializersUsingSet || shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const staticProperties = getStaticPropertiesAndClassStaticBlock(node);
|
|
if (some(staticProperties)) {
|
|
addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory2.getInternalName(node));
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function visitClassExpression(node) {
|
|
return visitInNewClassLexicalEnvironment(node, visitClassExpressionInNewClassLexicalEnvironment);
|
|
}
|
|
function visitClassExpressionInNewClassLexicalEnvironment(node, facts) {
|
|
const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
|
|
const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
|
|
const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */;
|
|
let temp;
|
|
function createClassTempVar() {
|
|
const classCheckFlags = resolver.getNodeCheckFlags(node);
|
|
const isClassWithConstructorReference2 = classCheckFlags & 1048576 /* ClassWithConstructorReference */;
|
|
const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
|
|
return factory2.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference2);
|
|
}
|
|
if (facts & 2 /* NeedsClassConstructorReference */) {
|
|
temp = createClassTempVar();
|
|
getClassLexicalEnvironment().classConstructor = factory2.cloneNode(temp);
|
|
}
|
|
const modifiers = visitNodes2(node.modifiers, visitor, isModifierLike);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
|
|
const { members, prologue } = transformClassMembers(node);
|
|
const classExpression = factory2.updateClassExpression(
|
|
node,
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
const expressions = [];
|
|
if (prologue) {
|
|
expressions.push(prologue);
|
|
}
|
|
const hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && some(staticPropertiesOrClassStaticBlocks, (node2) => isClassStaticBlockDeclaration(node2) || isPrivateIdentifierClassElementDeclaration(node2) || shouldTransformInitializers && isInitializedProperty(node2));
|
|
if (hasTransformableStatics || some(pendingExpressions)) {
|
|
if (isDecoratedClassDeclaration) {
|
|
Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
|
|
if (pendingStatements && pendingExpressions && some(pendingExpressions)) {
|
|
pendingStatements.push(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
}
|
|
if (pendingStatements && some(staticPropertiesOrClassStaticBlocks)) {
|
|
addPropertyOrClassStaticBlockStatements(pendingStatements, staticPropertiesOrClassStaticBlocks, factory2.getInternalName(node));
|
|
}
|
|
if (temp) {
|
|
expressions.push(
|
|
startOnNewLine(factory2.createAssignment(temp, classExpression)),
|
|
startOnNewLine(temp)
|
|
);
|
|
} else {
|
|
expressions.push(classExpression);
|
|
if (prologue) {
|
|
startOnNewLine(classExpression);
|
|
}
|
|
}
|
|
} else {
|
|
temp || (temp = createClassTempVar());
|
|
if (isClassWithConstructorReference) {
|
|
enableSubstitutionForClassAliases();
|
|
const alias = factory2.cloneNode(temp);
|
|
alias.autoGenerateFlags &= ~8 /* ReservedInNestedScopes */;
|
|
classAliases[getOriginalNodeId(node)] = alias;
|
|
}
|
|
setEmitFlags(classExpression, 131072 /* Indented */ | getEmitFlags(classExpression));
|
|
expressions.push(startOnNewLine(factory2.createAssignment(temp, classExpression)));
|
|
addRange(expressions, map(pendingExpressions, startOnNewLine));
|
|
addRange(expressions, generateInitializedPropertyExpressionsOrClassStaticBlock(staticPropertiesOrClassStaticBlocks, temp));
|
|
expressions.push(startOnNewLine(temp));
|
|
}
|
|
} else {
|
|
expressions.push(classExpression);
|
|
if (prologue) {
|
|
startOnNewLine(classExpression);
|
|
}
|
|
}
|
|
return factory2.inlineExpressions(expressions);
|
|
}
|
|
function visitClassStaticBlockDeclaration(node) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformClassMembers(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
for (const member of node.members) {
|
|
if (isPrivateIdentifierClassElementDeclaration(member)) {
|
|
addPrivateIdentifierToEnvironment(member, member.name, addPrivateIdentifierClassElementToEnvironment);
|
|
}
|
|
}
|
|
if (some(getPrivateInstanceMethodsAndAccessors(node))) {
|
|
createBrandCheckWeakSetForPrivateMethods();
|
|
}
|
|
if (shouldTransformAutoAccessors) {
|
|
for (const member of node.members) {
|
|
if (isAutoAccessorPropertyDeclaration(member)) {
|
|
const storageName = factory2.getGeneratedPrivateNameForNode(member.name, void 0, "_accessor_storage");
|
|
addPrivateIdentifierToEnvironment(member, storageName, addPrivateIdentifierPropertyDeclarationToEnvironment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let members = visitNodes2(node.members, classElementVisitor, isClassElement);
|
|
let syntheticConstructor;
|
|
if (!some(members, isConstructorDeclaration)) {
|
|
syntheticConstructor = transformConstructor(void 0, node);
|
|
}
|
|
let prologue;
|
|
let syntheticStaticBlock;
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks && some(pendingExpressions)) {
|
|
let statement = factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions));
|
|
if (statement.transformFlags & 134234112 /* ContainsLexicalThisOrSuper */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const arrow = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
void 0,
|
|
factory2.createBlock([statement])
|
|
);
|
|
prologue = factory2.createAssignment(temp, arrow);
|
|
statement = factory2.createExpressionStatement(factory2.createCallExpression(temp, void 0, []));
|
|
}
|
|
const block = factory2.createBlock([statement]);
|
|
syntheticStaticBlock = factory2.createClassStaticBlockDeclaration(block);
|
|
pendingExpressions = void 0;
|
|
}
|
|
if (syntheticConstructor || syntheticStaticBlock) {
|
|
let membersArray;
|
|
membersArray = append(membersArray, syntheticConstructor);
|
|
membersArray = append(membersArray, syntheticStaticBlock);
|
|
membersArray = addRange(membersArray, members);
|
|
members = setTextRange(factory2.createNodeArray(membersArray), node.members);
|
|
}
|
|
return { members, prologue };
|
|
}
|
|
function createBrandCheckWeakSetForPrivateMethods() {
|
|
const { weakSetName } = getPrivateIdentifierEnvironment();
|
|
Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
|
|
getPendingExpressions().push(
|
|
factory2.createAssignment(
|
|
weakSetName,
|
|
factory2.createNewExpression(
|
|
factory2.createIdentifier("WeakSet"),
|
|
void 0,
|
|
[]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function isClassElementThatRequiresConstructorStatement(member) {
|
|
if (isStatic(member) || hasAbstractModifier(getOriginalNode(member))) {
|
|
return false;
|
|
}
|
|
return shouldTransformInitializersUsingDefine && isPropertyDeclaration(member) || shouldTransformInitializersUsingSet && isInitializedProperty(member) || shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierClassElementDeclaration(member) || shouldTransformPrivateElementsOrClassStaticBlocks && shouldTransformAutoAccessors && isAutoAccessorPropertyDeclaration(member);
|
|
}
|
|
function transformConstructor(constructor, container) {
|
|
constructor = visitNode(constructor, visitor, isConstructorDeclaration);
|
|
if (!some(container.members, isClassElementThatRequiresConstructorStatement)) {
|
|
return constructor;
|
|
}
|
|
const extendsClauseElement = getEffectiveBaseTypeNode(container);
|
|
const isDerivedClass = !!(extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */);
|
|
const parameters = visitParameterList(constructor ? constructor.parameters : void 0, visitor, context);
|
|
const body = transformConstructorBody(container, constructor, isDerivedClass);
|
|
if (!body) {
|
|
return constructor;
|
|
}
|
|
if (constructor) {
|
|
Debug.assert(parameters);
|
|
return factory2.updateConstructorDeclaration(constructor, void 0, parameters, body);
|
|
}
|
|
return startOnNewLine(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createConstructorDeclaration(
|
|
void 0,
|
|
parameters != null ? parameters : [],
|
|
body
|
|
),
|
|
constructor || container
|
|
),
|
|
constructor
|
|
)
|
|
);
|
|
}
|
|
function transformConstructorBody(node, constructor, isDerivedClass) {
|
|
var _a2, _b;
|
|
let properties = getProperties(node, false, false);
|
|
if (!useDefineForClassFields) {
|
|
properties = filter(properties, (property) => !!property.initializer || isPrivateIdentifier(property.name) || hasAccessorModifier(property));
|
|
}
|
|
const privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
|
|
const needsConstructorBody = some(properties) || some(privateMethodsAndAccessors);
|
|
if (!constructor && !needsConstructorBody) {
|
|
return visitFunctionBody(void 0, visitor, context);
|
|
}
|
|
resumeLexicalEnvironment();
|
|
const needsSyntheticConstructor = !constructor && isDerivedClass;
|
|
let indexOfFirstStatementAfterSuperAndPrologue = 0;
|
|
let prologueStatementCount = 0;
|
|
let superStatementIndex = -1;
|
|
let statements = [];
|
|
if ((_a2 = constructor == null ? void 0 : constructor.body) == null ? void 0 : _a2.statements) {
|
|
prologueStatementCount = factory2.copyPrologue(constructor.body.statements, statements, false, visitor);
|
|
superStatementIndex = findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
|
|
if (superStatementIndex >= 0) {
|
|
indexOfFirstStatementAfterSuperAndPrologue = superStatementIndex + 1;
|
|
statements = [
|
|
...statements.slice(0, prologueStatementCount),
|
|
...visitNodes2(constructor.body.statements, visitor, isStatement, prologueStatementCount, indexOfFirstStatementAfterSuperAndPrologue - prologueStatementCount),
|
|
...statements.slice(prologueStatementCount)
|
|
];
|
|
} else if (prologueStatementCount >= 0) {
|
|
indexOfFirstStatementAfterSuperAndPrologue = prologueStatementCount;
|
|
}
|
|
}
|
|
if (needsSyntheticConstructor) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createSuper(),
|
|
void 0,
|
|
[factory2.createSpreadElement(factory2.createIdentifier("arguments"))]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
let parameterPropertyDeclarationCount = 0;
|
|
if (constructor == null ? void 0 : constructor.body) {
|
|
if (useDefineForClassFields) {
|
|
statements = statements.filter((statement) => !isParameterPropertyDeclaration(getOriginalNode(statement), constructor));
|
|
} else {
|
|
for (const statement of constructor.body.statements) {
|
|
if (isParameterPropertyDeclaration(getOriginalNode(statement), constructor)) {
|
|
parameterPropertyDeclarationCount++;
|
|
}
|
|
}
|
|
if (parameterPropertyDeclarationCount > 0) {
|
|
const parameterProperties = visitNodes2(constructor.body.statements, visitor, isStatement, indexOfFirstStatementAfterSuperAndPrologue, parameterPropertyDeclarationCount);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(statements, parameterProperties);
|
|
} else {
|
|
let superAndPrologueStatementCount = prologueStatementCount;
|
|
if (needsSyntheticConstructor)
|
|
superAndPrologueStatementCount++;
|
|
statements = [
|
|
...statements.slice(0, superAndPrologueStatementCount),
|
|
...parameterProperties,
|
|
...statements.slice(superAndPrologueStatementCount)
|
|
];
|
|
}
|
|
indexOfFirstStatementAfterSuperAndPrologue += parameterPropertyDeclarationCount;
|
|
}
|
|
}
|
|
}
|
|
const receiver = factory2.createThis();
|
|
addMethodStatements(statements, privateMethodsAndAccessors, receiver);
|
|
addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
|
|
if (constructor) {
|
|
addRange(statements, visitNodes2(constructor.body.statements, visitBodyStatement, isStatement, indexOfFirstStatementAfterSuperAndPrologue));
|
|
}
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
if (statements.length === 0 && !constructor) {
|
|
return void 0;
|
|
}
|
|
const multiLine = (constructor == null ? void 0 : constructor.body) && constructor.body.statements.length >= statements.length ? (_b = constructor.body.multiLine) != null ? _b : statements.length > 0 : statements.length > 0;
|
|
return setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(statements),
|
|
constructor ? constructor.body.statements : node.members
|
|
),
|
|
multiLine
|
|
),
|
|
constructor ? constructor.body : void 0
|
|
);
|
|
function visitBodyStatement(statement) {
|
|
if (useDefineForClassFields && isParameterPropertyDeclaration(getOriginalNode(statement), constructor)) {
|
|
return void 0;
|
|
}
|
|
return visitor(statement);
|
|
}
|
|
}
|
|
function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
|
|
for (const property of properties) {
|
|
if (isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
|
|
continue;
|
|
}
|
|
const statement = transformPropertyOrClassStaticBlock(property, receiver);
|
|
if (!statement) {
|
|
continue;
|
|
}
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
function transformPropertyOrClassStaticBlock(property, receiver) {
|
|
const expression = isClassStaticBlockDeclaration(property) ? transformClassStaticBlockDeclaration(property) : transformProperty(property, receiver);
|
|
if (!expression) {
|
|
return void 0;
|
|
}
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
setOriginalNode(statement, property);
|
|
addEmitFlags(statement, getEmitFlags(property) & 3072 /* NoComments */);
|
|
setSourceMapRange(statement, moveRangePastModifiers(property));
|
|
setCommentRange(statement, property);
|
|
setSyntheticLeadingComments(expression, void 0);
|
|
setSyntheticTrailingComments(expression, void 0);
|
|
return statement;
|
|
}
|
|
function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) {
|
|
const expressions = [];
|
|
for (const property of propertiesOrClassStaticBlocks) {
|
|
const expression = isClassStaticBlockDeclaration(property) ? transformClassStaticBlockDeclaration(property) : transformProperty(property, receiver);
|
|
if (!expression) {
|
|
continue;
|
|
}
|
|
startOnNewLine(expression);
|
|
setOriginalNode(expression, property);
|
|
addEmitFlags(expression, getEmitFlags(property) & 3072 /* NoComments */);
|
|
setSourceMapRange(expression, moveRangePastModifiers(property));
|
|
setCommentRange(expression, property);
|
|
expressions.push(expression);
|
|
}
|
|
return expressions;
|
|
}
|
|
function transformProperty(property, receiver) {
|
|
const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock;
|
|
const transformed = transformPropertyWorker(property, receiver);
|
|
if (transformed && hasStaticModifier(property) && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.facts)) {
|
|
setOriginalNode(transformed, property);
|
|
addEmitFlags(transformed, 4 /* AdviseOnEmitNode */);
|
|
classLexicalEnvironmentMap.set(getOriginalNodeId(transformed), currentClassLexicalEnvironment);
|
|
}
|
|
currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock;
|
|
return transformed;
|
|
}
|
|
function transformPropertyWorker(property, receiver) {
|
|
var _a2;
|
|
const emitAssignment = !useDefineForClassFields;
|
|
const propertyName = hasAccessorModifier(property) ? factory2.getGeneratedPrivateNameForNode(property.name) : isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression) ? factory2.updateComputedPropertyName(property.name, factory2.getGeneratedNameForNode(property.name)) : property.name;
|
|
if (hasStaticModifier(property)) {
|
|
currentStaticPropertyDeclarationOrStaticBlock = property;
|
|
}
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifier(propertyName)) {
|
|
const privateIdentifierInfo = accessPrivateIdentifier(propertyName);
|
|
if (privateIdentifierInfo) {
|
|
if (privateIdentifierInfo.kind === "f" /* Field */) {
|
|
if (!privateIdentifierInfo.isStatic) {
|
|
return createPrivateInstanceFieldInitializer(
|
|
receiver,
|
|
visitNode(property.initializer, visitor, isExpression),
|
|
privateIdentifierInfo.brandCheckIdentifier
|
|
);
|
|
} else {
|
|
return createPrivateStaticFieldInitializer(
|
|
privateIdentifierInfo.variableName,
|
|
visitNode(property.initializer, visitor, isExpression)
|
|
);
|
|
}
|
|
} else {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
Debug.fail("Undeclared private name for property declaration.");
|
|
}
|
|
}
|
|
if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property)) && !property.initializer) {
|
|
return void 0;
|
|
}
|
|
const propertyOriginalNode = getOriginalNode(property);
|
|
if (hasSyntacticModifier(propertyOriginalNode, 256 /* Abstract */)) {
|
|
return void 0;
|
|
}
|
|
const initializer = property.initializer || emitAssignment ? (_a2 = visitNode(property.initializer, visitor, isExpression)) != null ? _a2 : factory2.createVoidZero() : isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && isIdentifier(propertyName) ? propertyName : factory2.createVoidZero();
|
|
if (emitAssignment || isPrivateIdentifier(propertyName)) {
|
|
const memberAccess = createMemberAccessForPropertyName(factory2, receiver, propertyName, propertyName);
|
|
return factory2.createAssignment(memberAccess, initializer);
|
|
} else {
|
|
const name = isComputedPropertyName(propertyName) ? propertyName.expression : isIdentifier(propertyName) ? factory2.createStringLiteral(unescapeLeadingUnderscores(propertyName.escapedText)) : propertyName;
|
|
const descriptor = factory2.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
|
|
return factory2.createObjectDefinePropertyCall(receiver, name, descriptor);
|
|
}
|
|
}
|
|
function enableSubstitutionForClassAliases() {
|
|
if ((enabledSubstitutions & 1 /* ClassAliases */) === 0) {
|
|
enabledSubstitutions |= 1 /* ClassAliases */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
classAliases = [];
|
|
}
|
|
}
|
|
function enableSubstitutionForClassStaticThisOrSuperReference() {
|
|
if ((enabledSubstitutions & 2 /* ClassStaticThisOrSuperReference */) === 0) {
|
|
enabledSubstitutions |= 2 /* ClassStaticThisOrSuperReference */;
|
|
context.enableSubstitution(108 /* ThisKeyword */);
|
|
context.enableEmitNotification(259 /* FunctionDeclaration */);
|
|
context.enableEmitNotification(215 /* FunctionExpression */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(169 /* PropertyDeclaration */);
|
|
context.enableEmitNotification(164 /* ComputedPropertyName */);
|
|
}
|
|
}
|
|
function addMethodStatements(statements, methods, receiver) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks || !some(methods)) {
|
|
return;
|
|
}
|
|
const { weakSetName } = getPrivateIdentifierEnvironment();
|
|
Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
createPrivateInstanceMethodInitializer(receiver, weakSetName)
|
|
)
|
|
);
|
|
}
|
|
function visitInvalidSuperProperty(node) {
|
|
return isPropertyAccessExpression(node) ? factory2.updatePropertyAccessExpression(
|
|
node,
|
|
factory2.createVoidZero(),
|
|
node.name
|
|
) : factory2.updateElementAccessExpression(
|
|
node,
|
|
factory2.createVoidZero(),
|
|
visitNode(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
const original = getOriginalNode(node);
|
|
if (original.id) {
|
|
const classLexicalEnvironment = classLexicalEnvironmentMap.get(original.id);
|
|
if (classLexicalEnvironment) {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = classLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = classLexicalEnvironment;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) {
|
|
break;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 173 /* Constructor */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = void 0;
|
|
currentComputedPropertyNameClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 169 /* PropertyDeclaration */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
case 164 /* ComputedPropertyName */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 108 /* ThisKeyword */:
|
|
return substituteThisExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteThisExpression(node) {
|
|
if (enabledSubstitutions & 2 /* ClassStaticThisOrSuperReference */ && currentClassLexicalEnvironment) {
|
|
const { facts, classConstructor } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return factory2.createParenthesizedExpression(factory2.createVoidZero());
|
|
}
|
|
if (classConstructor) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
factory2.cloneNode(classConstructor),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
return trySubstituteClassAlias(node) || node;
|
|
}
|
|
function trySubstituteClassAlias(node) {
|
|
if (enabledSubstitutions & 1 /* ClassAliases */) {
|
|
if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
|
|
const declaration = resolver.getReferencedValueDeclaration(node);
|
|
if (declaration) {
|
|
const classAlias = classAliases[declaration.id];
|
|
if (classAlias) {
|
|
const clone2 = factory2.cloneNode(classAlias);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPropertyNameExpressionIfNeeded(name, shouldHoist) {
|
|
if (isComputedPropertyName(name)) {
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const innerExpression = skipPartiallyEmittedExpressions(expression);
|
|
const inlinable = isSimpleInlineableExpression(innerExpression);
|
|
const alreadyTransformed = isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
|
|
if (!alreadyTransformed && !inlinable && shouldHoist) {
|
|
const generatedName = factory2.getGeneratedNameForNode(name);
|
|
if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
|
|
addBlockScopedVariable(generatedName);
|
|
} else {
|
|
hoistVariableDeclaration(generatedName);
|
|
}
|
|
return factory2.createAssignment(generatedName, expression);
|
|
}
|
|
return inlinable || isIdentifier(innerExpression) ? void 0 : expression;
|
|
}
|
|
}
|
|
function startClassLexicalEnvironment() {
|
|
classLexicalEnvironmentStack.push(currentClassLexicalEnvironment);
|
|
currentClassLexicalEnvironment = void 0;
|
|
}
|
|
function endClassLexicalEnvironment() {
|
|
currentClassLexicalEnvironment = classLexicalEnvironmentStack.pop();
|
|
}
|
|
function getClassLexicalEnvironment() {
|
|
return currentClassLexicalEnvironment || (currentClassLexicalEnvironment = {
|
|
facts: 0 /* None */,
|
|
classConstructor: void 0,
|
|
superClassReference: void 0,
|
|
privateIdentifierEnvironment: void 0
|
|
});
|
|
}
|
|
function getPrivateIdentifierEnvironment() {
|
|
const lex = getClassLexicalEnvironment();
|
|
lex.privateIdentifierEnvironment || (lex.privateIdentifierEnvironment = {
|
|
className: void 0,
|
|
weakSetName: void 0,
|
|
identifiers: void 0,
|
|
generatedIdentifiers: void 0
|
|
});
|
|
return lex.privateIdentifierEnvironment;
|
|
}
|
|
function getPendingExpressions() {
|
|
return pendingExpressions != null ? pendingExpressions : pendingExpressions = [];
|
|
}
|
|
function addPrivateIdentifierClassElementToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
if (isAutoAccessorPropertyDeclaration(node)) {
|
|
addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isPropertyDeclaration(node)) {
|
|
addPrivateIdentifierPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isMethodDeclaration(node)) {
|
|
addPrivateIdentifierMethodDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isGetAccessorDeclaration(node)) {
|
|
addPrivateIdentifierGetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isSetAccessorDeclaration(node)) {
|
|
addPrivateIdentifierSetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
}
|
|
}
|
|
function addPrivateIdentifierPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
if (isStatic2) {
|
|
Debug.assert(lex.classConstructor, "classConstructor should be set in private identifier environment");
|
|
const variableName = createHoistedVariableForPrivateName(name);
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "f" /* Field */,
|
|
brandCheckIdentifier: lex.classConstructor,
|
|
variableName,
|
|
isStatic: true,
|
|
isValid
|
|
});
|
|
} else {
|
|
const weakMapName = createHoistedVariableForPrivateName(name);
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "f" /* Field */,
|
|
brandCheckIdentifier: weakMapName,
|
|
variableName: void 0,
|
|
isStatic: false,
|
|
isValid
|
|
});
|
|
getPendingExpressions().push(factory2.createAssignment(
|
|
weakMapName,
|
|
factory2.createNewExpression(
|
|
factory2.createIdentifier("WeakMap"),
|
|
void 0,
|
|
[]
|
|
)
|
|
));
|
|
}
|
|
}
|
|
function addPrivateIdentifierMethodDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
const methodName = createHoistedVariableForPrivateName(name);
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "m" /* Method */,
|
|
methodName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
function addPrivateIdentifierGetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
const getterName = createHoistedVariableForPrivateName(name, "_get");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
if ((previousInfo == null ? void 0 : previousInfo.kind) === "a" /* Accessor */ && previousInfo.isStatic === isStatic2 && !previousInfo.getterName) {
|
|
previousInfo.getterName = getterName;
|
|
} else {
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName,
|
|
setterName: void 0,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
}
|
|
function addPrivateIdentifierSetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
const setterName = createHoistedVariableForPrivateName(name, "_set");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
if ((previousInfo == null ? void 0 : previousInfo.kind) === "a" /* Accessor */ && previousInfo.isStatic === isStatic2 && !previousInfo.setterName) {
|
|
previousInfo.setterName = setterName;
|
|
} else {
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName: void 0,
|
|
setterName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
}
|
|
function addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
const getterName = createHoistedVariableForPrivateName(name, "_get");
|
|
const setterName = createHoistedVariableForPrivateName(name, "_set");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName,
|
|
setterName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
function addPrivateIdentifierToEnvironment(node, name, addDeclaration) {
|
|
const lex = getClassLexicalEnvironment();
|
|
const privateEnv = getPrivateIdentifierEnvironment();
|
|
const previousInfo = getPrivateIdentifier(privateEnv, name);
|
|
const isStatic2 = hasStaticModifier(node);
|
|
const isValid = !isReservedPrivateName(name) && previousInfo === void 0;
|
|
addDeclaration(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
}
|
|
function createHoistedVariableForClass(name, node, suffix) {
|
|
const { className } = getPrivateIdentifierEnvironment();
|
|
const prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_";
|
|
const identifier = typeof name === "object" ? factory2.getGeneratedNameForNode(name, 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */, prefix, suffix) : typeof name === "string" ? factory2.createUniqueName(name, 16 /* Optimistic */, prefix, suffix) : factory2.createTempVariable(void 0, true, prefix, suffix);
|
|
if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
|
|
addBlockScopedVariable(identifier);
|
|
} else {
|
|
hoistVariableDeclaration(identifier);
|
|
}
|
|
return identifier;
|
|
}
|
|
function createHoistedVariableForPrivateName(name, suffix) {
|
|
var _a2;
|
|
const text = tryGetTextOfPropertyName(name);
|
|
return createHoistedVariableForClass((_a2 = text == null ? void 0 : text.substring(1)) != null ? _a2 : name, name, suffix);
|
|
}
|
|
function accessPrivateIdentifier(name) {
|
|
if (isGeneratedPrivateIdentifier(name)) {
|
|
return accessGeneratedPrivateIdentifier(name);
|
|
} else {
|
|
return accessPrivateIdentifierByText(name.escapedText);
|
|
}
|
|
}
|
|
function accessPrivateIdentifierByText(text) {
|
|
return accessPrivateIdentifierWorker(getPrivateIdentifierInfo, text);
|
|
}
|
|
function accessGeneratedPrivateIdentifier(name) {
|
|
return accessPrivateIdentifierWorker(getGeneratedPrivateIdentifierInfo, getNodeForGeneratedName(name));
|
|
}
|
|
function accessPrivateIdentifierWorker(getPrivateIdentifierInfo2, privateIdentifierKey) {
|
|
if (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.privateIdentifierEnvironment) {
|
|
const info = getPrivateIdentifierInfo2(currentClassLexicalEnvironment.privateIdentifierEnvironment, privateIdentifierKey);
|
|
if (info) {
|
|
return info;
|
|
}
|
|
}
|
|
for (let i = classLexicalEnvironmentStack.length - 1; i >= 0; --i) {
|
|
const env = classLexicalEnvironmentStack[i];
|
|
if (!env) {
|
|
continue;
|
|
}
|
|
if (env.privateIdentifierEnvironment) {
|
|
const info = getPrivateIdentifierInfo2(env.privateIdentifierEnvironment, privateIdentifierKey);
|
|
if (info) {
|
|
return info;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function wrapPrivateIdentifierForDestructuringTarget(node) {
|
|
const parameter = factory2.getGeneratedNameForNode(node);
|
|
const info = accessPrivateIdentifier(node.name);
|
|
if (!info) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
let receiver = node.expression;
|
|
if (isThisProperty(node) || isSuperProperty(node) || !isSimpleCopiableExpression(node.expression)) {
|
|
receiver = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getPendingExpressions().push(factory2.createBinaryExpression(receiver, 63 /* EqualsToken */, visitNode(node.expression, visitor, isExpression)));
|
|
}
|
|
return factory2.createAssignmentTargetWrapper(
|
|
parameter,
|
|
createPrivateIdentifierAssignment(
|
|
info,
|
|
receiver,
|
|
parameter,
|
|
63 /* EqualsToken */
|
|
)
|
|
);
|
|
}
|
|
function visitArrayAssignmentTarget(node) {
|
|
const target = getTargetOfBindingOrAssignmentElement(node);
|
|
if (target) {
|
|
let wrapped;
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(target) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
wrapped = visitInvalidSuperProperty(target);
|
|
} else if (classConstructor && superClassReference) {
|
|
const name = isElementAccessExpression(target) ? visitNode(target.argumentExpression, visitor, isExpression) : isIdentifier(target.name) ? factory2.createStringLiteralFromNode(target.name) : void 0;
|
|
if (name) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
wrapped = factory2.createAssignmentTargetWrapper(
|
|
temp,
|
|
factory2.createReflectSetCall(
|
|
superClassReference,
|
|
name,
|
|
temp,
|
|
classConstructor
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (wrapped) {
|
|
if (isAssignmentExpression(node)) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
wrapped,
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
} else if (isSpreadElement(node)) {
|
|
return factory2.updateSpreadElement(node, wrapped);
|
|
} else {
|
|
return wrapped;
|
|
}
|
|
}
|
|
}
|
|
return visitNode(node, assignmentTargetVisitor);
|
|
}
|
|
function visitObjectAssignmentTarget(node) {
|
|
if (isObjectBindingOrAssignmentElement(node) && !isShorthandPropertyAssignment(node)) {
|
|
const target = getTargetOfBindingOrAssignmentElement(node);
|
|
let wrapped;
|
|
if (target) {
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(target) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
wrapped = visitInvalidSuperProperty(target);
|
|
} else if (classConstructor && superClassReference) {
|
|
const name = isElementAccessExpression(target) ? visitNode(target.argumentExpression, visitor, isExpression) : isIdentifier(target.name) ? factory2.createStringLiteralFromNode(target.name) : void 0;
|
|
if (name) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
wrapped = factory2.createAssignmentTargetWrapper(
|
|
temp,
|
|
factory2.createReflectSetCall(
|
|
superClassReference,
|
|
name,
|
|
temp,
|
|
classConstructor
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isPropertyAssignment(node)) {
|
|
const initializer = getInitializerOfBindingOrAssignmentElement(node);
|
|
return factory2.updatePropertyAssignment(
|
|
node,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
wrapped ? initializer ? factory2.createAssignment(wrapped, visitNode(initializer, visitor)) : wrapped : visitNode(node.initializer, assignmentTargetVisitor, isExpression)
|
|
);
|
|
}
|
|
if (isSpreadAssignment(node)) {
|
|
return factory2.updateSpreadAssignment(
|
|
node,
|
|
wrapped || visitNode(node.expression, assignmentTargetVisitor, isExpression)
|
|
);
|
|
}
|
|
Debug.assert(wrapped === void 0, "Should not have generated a wrapped target");
|
|
}
|
|
return visitNode(node, visitor);
|
|
}
|
|
function visitAssignmentPattern(node) {
|
|
if (isArrayLiteralExpression(node)) {
|
|
return factory2.updateArrayLiteralExpression(
|
|
node,
|
|
visitNodes2(node.elements, visitArrayAssignmentTarget, isExpression)
|
|
);
|
|
} else {
|
|
return factory2.updateObjectLiteralExpression(
|
|
node,
|
|
visitNodes2(node.properties, visitObjectAssignmentTarget, isObjectLiteralElementLike)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function createPrivateStaticFieldInitializer(variableName, initializer) {
|
|
return factory.createAssignment(
|
|
variableName,
|
|
factory.createObjectLiteralExpression([
|
|
factory.createPropertyAssignment("value", initializer || factory.createVoidZero())
|
|
])
|
|
);
|
|
}
|
|
function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
|
|
return factory.createCallExpression(
|
|
factory.createPropertyAccessExpression(weakMapName, "set"),
|
|
void 0,
|
|
[receiver, initializer || factory.createVoidZero()]
|
|
);
|
|
}
|
|
function createPrivateInstanceMethodInitializer(receiver, weakSetName) {
|
|
return factory.createCallExpression(
|
|
factory.createPropertyAccessExpression(weakSetName, "add"),
|
|
void 0,
|
|
[receiver]
|
|
);
|
|
}
|
|
function isReservedPrivateName(node) {
|
|
return !isGeneratedPrivateIdentifier(node) && node.escapedText === "#constructor";
|
|
}
|
|
function getPrivateIdentifier(privateEnv, name) {
|
|
return isGeneratedPrivateIdentifier(name) ? getGeneratedPrivateIdentifierInfo(privateEnv, getNodeForGeneratedName(name)) : getPrivateIdentifierInfo(privateEnv, name.escapedText);
|
|
}
|
|
function setPrivateIdentifier(privateEnv, name, info) {
|
|
var _a2, _b;
|
|
if (isGeneratedPrivateIdentifier(name)) {
|
|
(_a2 = privateEnv.generatedIdentifiers) != null ? _a2 : privateEnv.generatedIdentifiers = /* @__PURE__ */ new Map();
|
|
privateEnv.generatedIdentifiers.set(getNodeForGeneratedName(name), info);
|
|
} else {
|
|
(_b = privateEnv.identifiers) != null ? _b : privateEnv.identifiers = /* @__PURE__ */ new Map();
|
|
privateEnv.identifiers.set(name.escapedText, info);
|
|
}
|
|
}
|
|
function getPrivateIdentifierInfo(privateEnv, key) {
|
|
var _a2;
|
|
return (_a2 = privateEnv.identifiers) == null ? void 0 : _a2.get(key);
|
|
}
|
|
function getGeneratedPrivateIdentifierInfo(privateEnv, key) {
|
|
var _a2;
|
|
return (_a2 = privateEnv.generatedIdentifiers) == null ? void 0 : _a2.get(key);
|
|
}
|
|
|
|
// src/compiler/transformers/typeSerializer.ts
|
|
function createRuntimeTypeSerializer(context) {
|
|
const {
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
|
|
let currentLexicalScope;
|
|
let currentNameScope;
|
|
return {
|
|
serializeTypeNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeNode, node),
|
|
serializeTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node),
|
|
serializeParameterTypesOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container),
|
|
serializeReturnTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node)
|
|
};
|
|
function setSerializerContextAnd(serializerContext, cb, node, arg) {
|
|
const savedCurrentLexicalScope = currentLexicalScope;
|
|
const savedCurrentNameScope = currentNameScope;
|
|
currentLexicalScope = serializerContext.currentLexicalScope;
|
|
currentNameScope = serializerContext.currentNameScope;
|
|
const result = arg === void 0 ? cb(node) : cb(node, arg);
|
|
currentLexicalScope = savedCurrentLexicalScope;
|
|
currentNameScope = savedCurrentNameScope;
|
|
return result;
|
|
}
|
|
function getAccessorTypeNode(node) {
|
|
const accessors = resolver.getAllAccessorDeclarations(node);
|
|
return accessors.setAccessor && getSetAccessorTypeAnnotationNode(accessors.setAccessor) || accessors.getAccessor && getEffectiveReturnTypeNode(accessors.getAccessor);
|
|
}
|
|
function serializeTypeOfNode(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 166 /* Parameter */:
|
|
return serializeTypeNode(node.type);
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
return serializeTypeNode(getAccessorTypeNode(node));
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
return factory.createIdentifier("Function");
|
|
default:
|
|
return factory.createVoidZero();
|
|
}
|
|
}
|
|
function serializeParameterTypesOfNode(node, container) {
|
|
const valueDeclaration = isClassLike(node) ? getFirstConstructorWithBody(node) : isFunctionLike(node) && nodeIsPresent(node.body) ? node : void 0;
|
|
const expressions = [];
|
|
if (valueDeclaration) {
|
|
const parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container);
|
|
const numParameters = parameters.length;
|
|
for (let i = 0; i < numParameters; i++) {
|
|
const parameter = parameters[i];
|
|
if (i === 0 && isIdentifier(parameter.name) && parameter.name.escapedText === "this") {
|
|
continue;
|
|
}
|
|
if (parameter.dotDotDotToken) {
|
|
expressions.push(serializeTypeNode(getRestParameterElementType(parameter.type)));
|
|
} else {
|
|
expressions.push(serializeTypeOfNode(parameter));
|
|
}
|
|
}
|
|
}
|
|
return factory.createArrayLiteralExpression(expressions);
|
|
}
|
|
function getParametersOfDecoratedDeclaration(node, container) {
|
|
if (container && node.kind === 174 /* GetAccessor */) {
|
|
const { setAccessor } = getAllAccessorDeclarations(container.members, node);
|
|
if (setAccessor) {
|
|
return setAccessor.parameters;
|
|
}
|
|
}
|
|
return node.parameters;
|
|
}
|
|
function serializeReturnTypeOfNode(node) {
|
|
if (isFunctionLike(node) && node.type) {
|
|
return serializeTypeNode(node.type);
|
|
} else if (isAsyncFunction(node)) {
|
|
return factory.createIdentifier("Promise");
|
|
}
|
|
return factory.createVoidZero();
|
|
}
|
|
function serializeTypeNode(node) {
|
|
if (node === void 0) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
node = skipTypeParentheses(node);
|
|
switch (node.kind) {
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
return factory.createVoidZero();
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return factory.createIdentifier("Function");
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return factory.createIdentifier("Array");
|
|
case 179 /* TypePredicate */:
|
|
return node.assertsModifier ? factory.createVoidZero() : factory.createIdentifier("Boolean");
|
|
case 134 /* BooleanKeyword */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 200 /* TemplateLiteralType */:
|
|
case 152 /* StringKeyword */:
|
|
return factory.createIdentifier("String");
|
|
case 149 /* ObjectKeyword */:
|
|
return factory.createIdentifier("Object");
|
|
case 198 /* LiteralType */:
|
|
return serializeLiteralOfLiteralTypeNode(node.literal);
|
|
case 148 /* NumberKeyword */:
|
|
return factory.createIdentifier("Number");
|
|
case 160 /* BigIntKeyword */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 153 /* SymbolKeyword */:
|
|
return getGlobalConstructor("Symbol", 2 /* ES2015 */);
|
|
case 180 /* TypeReference */:
|
|
return serializeTypeReferenceNode(node);
|
|
case 190 /* IntersectionType */:
|
|
return serializeUnionOrIntersectionConstituents(node.types, true);
|
|
case 189 /* UnionType */:
|
|
return serializeUnionOrIntersectionConstituents(node.types, false);
|
|
case 191 /* ConditionalType */:
|
|
return serializeUnionOrIntersectionConstituents([node.trueType, node.falseType], false);
|
|
case 195 /* TypeOperator */:
|
|
if (node.operator === 146 /* ReadonlyKeyword */) {
|
|
return serializeTypeNode(node.type);
|
|
}
|
|
break;
|
|
case 183 /* TypeQuery */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 197 /* MappedType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 194 /* ThisType */:
|
|
case 202 /* ImportType */:
|
|
break;
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 321 /* JSDocVariadicType */:
|
|
case 322 /* JSDocNamepathType */:
|
|
break;
|
|
case 317 /* JSDocNullableType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 319 /* JSDocOptionalType */:
|
|
return serializeTypeNode(node.type);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
function serializeLiteralOfLiteralTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return factory.createIdentifier("String");
|
|
case 221 /* PrefixUnaryExpression */: {
|
|
const operand = node.operand;
|
|
switch (operand.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return serializeLiteralOfLiteralTypeNode(operand);
|
|
default:
|
|
return Debug.failBadSyntaxKind(operand);
|
|
}
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
return factory.createIdentifier("Number");
|
|
case 9 /* BigIntLiteral */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 104 /* NullKeyword */:
|
|
return factory.createVoidZero();
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function serializeUnionOrIntersectionConstituents(types, isIntersection) {
|
|
let serializedType;
|
|
for (let typeNode of types) {
|
|
typeNode = skipTypeParentheses(typeNode);
|
|
if (typeNode.kind === 144 /* NeverKeyword */) {
|
|
if (isIntersection)
|
|
return factory.createVoidZero();
|
|
continue;
|
|
}
|
|
if (typeNode.kind === 157 /* UnknownKeyword */) {
|
|
if (!isIntersection)
|
|
return factory.createIdentifier("Object");
|
|
continue;
|
|
}
|
|
if (typeNode.kind === 131 /* AnyKeyword */) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
if (!strictNullChecks && (isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
|
|
continue;
|
|
}
|
|
const serializedConstituent = serializeTypeNode(typeNode);
|
|
if (isIdentifier(serializedConstituent) && serializedConstituent.escapedText === "Object") {
|
|
return serializedConstituent;
|
|
}
|
|
if (serializedType) {
|
|
if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
} else {
|
|
serializedType = serializedConstituent;
|
|
}
|
|
}
|
|
return serializedType != null ? serializedType : factory.createVoidZero();
|
|
}
|
|
function equateSerializedTypeNodes(left, right) {
|
|
return isGeneratedIdentifier(left) ? isGeneratedIdentifier(right) : isIdentifier(left) ? isIdentifier(right) && left.escapedText === right.escapedText : isPropertyAccessExpression(left) ? isPropertyAccessExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) && equateSerializedTypeNodes(left.name, right.name) : isVoidExpression(left) ? isVoidExpression(right) && isNumericLiteral(left.expression) && left.expression.text === "0" && isNumericLiteral(right.expression) && right.expression.text === "0" : isStringLiteral(left) ? isStringLiteral(right) && left.text === right.text : isTypeOfExpression(left) ? isTypeOfExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) : isParenthesizedExpression(left) ? isParenthesizedExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) : isConditionalExpression(left) ? isConditionalExpression(right) && equateSerializedTypeNodes(left.condition, right.condition) && equateSerializedTypeNodes(left.whenTrue, right.whenTrue) && equateSerializedTypeNodes(left.whenFalse, right.whenFalse) : isBinaryExpression(left) ? isBinaryExpression(right) && left.operatorToken.kind === right.operatorToken.kind && equateSerializedTypeNodes(left.left, right.left) && equateSerializedTypeNodes(left.right, right.right) : false;
|
|
}
|
|
function serializeTypeReferenceNode(node) {
|
|
const kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope != null ? currentNameScope : currentLexicalScope);
|
|
switch (kind) {
|
|
case 0 /* Unknown */:
|
|
if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
const serialized = serializeEntityNameAsExpressionFallback(node.typeName);
|
|
const temp = factory.createTempVariable(hoistVariableDeclaration);
|
|
return factory.createConditionalExpression(
|
|
factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"),
|
|
void 0,
|
|
temp,
|
|
void 0,
|
|
factory.createIdentifier("Object")
|
|
);
|
|
case 1 /* TypeWithConstructSignatureAndValue */:
|
|
return serializeEntityNameAsExpression(node.typeName);
|
|
case 2 /* VoidNullableOrNeverType */:
|
|
return factory.createVoidZero();
|
|
case 4 /* BigIntLikeType */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 6 /* BooleanType */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 3 /* NumberLikeType */:
|
|
return factory.createIdentifier("Number");
|
|
case 5 /* StringLikeType */:
|
|
return factory.createIdentifier("String");
|
|
case 7 /* ArrayLikeType */:
|
|
return factory.createIdentifier("Array");
|
|
case 8 /* ESSymbolType */:
|
|
return getGlobalConstructor("Symbol", 2 /* ES2015 */);
|
|
case 10 /* TypeWithCallSignature */:
|
|
return factory.createIdentifier("Function");
|
|
case 9 /* Promise */:
|
|
return factory.createIdentifier("Promise");
|
|
case 11 /* ObjectType */:
|
|
return factory.createIdentifier("Object");
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function createCheckedValue(left, right) {
|
|
return factory.createLogicalAnd(
|
|
factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")),
|
|
right
|
|
);
|
|
}
|
|
function serializeEntityNameAsExpressionFallback(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
const copied = serializeEntityNameAsExpression(node);
|
|
return createCheckedValue(copied, copied);
|
|
}
|
|
if (node.left.kind === 79 /* Identifier */) {
|
|
return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
|
|
}
|
|
const left = serializeEntityNameAsExpressionFallback(node.left);
|
|
const temp = factory.createTempVariable(hoistVariableDeclaration);
|
|
return factory.createLogicalAnd(
|
|
factory.createLogicalAnd(
|
|
left.left,
|
|
factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero())
|
|
),
|
|
factory.createPropertyAccessExpression(temp, node.right)
|
|
);
|
|
}
|
|
function serializeEntityNameAsExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
const name = setParent(setTextRange(parseNodeFactory.cloneNode(node), node), node.parent);
|
|
name.original = void 0;
|
|
setParent(name, getParseTreeNode(currentLexicalScope));
|
|
return name;
|
|
case 163 /* QualifiedName */:
|
|
return serializeQualifiedNameAsExpression(node);
|
|
}
|
|
}
|
|
function serializeQualifiedNameAsExpression(node) {
|
|
return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
|
|
}
|
|
function getGlobalConstructorWithFallback(name) {
|
|
return factory.createConditionalExpression(
|
|
factory.createTypeCheck(factory.createIdentifier(name), "function"),
|
|
void 0,
|
|
factory.createIdentifier(name),
|
|
void 0,
|
|
factory.createIdentifier("Object")
|
|
);
|
|
}
|
|
function getGlobalConstructor(name, minLanguageVersion) {
|
|
return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory.createIdentifier(name);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/legacyDecorators.ts
|
|
function transformLegacyDecorators(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let classAliases;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function modifierVisitor(node) {
|
|
return isDecorator(node) ? void 0 : node;
|
|
}
|
|
function visitor(node) {
|
|
if (!(node.transformFlags & 33554432 /* ContainsDecorators */)) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 167 /* Decorator */:
|
|
return void 0;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 173 /* Constructor */:
|
|
return visitConstructorDeclaration(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessorDeclaration(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameterDeclaration(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
if (!(classOrConstructorParameterIsDecorated(node) || childIsDecorated(node)))
|
|
return visitEachChild(node, visitor, context);
|
|
const statements = hasDecorators(node) ? transformClassDeclarationWithClassDecorators(node, node.name) : transformClassDeclarationWithoutClassDecorators(node, node.name);
|
|
if (statements.length > 1) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(statements[0], getEmitFlags(statements[0]) | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function decoratorContainsPrivateIdentifierInExpression(decorator) {
|
|
return !!(decorator.transformFlags & 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
}
|
|
function parameterDecoratorsContainPrivateIdentifierInExpression(parameterDecorators) {
|
|
return some(parameterDecorators, decoratorContainsPrivateIdentifierInExpression);
|
|
}
|
|
function hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node) {
|
|
for (const member of node.members) {
|
|
if (!canHaveDecorators(member))
|
|
continue;
|
|
const allDecorators = getAllDecoratorsOfClassElement(member, node);
|
|
if (some(allDecorators == null ? void 0 : allDecorators.decorators, decoratorContainsPrivateIdentifierInExpression))
|
|
return true;
|
|
if (some(allDecorators == null ? void 0 : allDecorators.parameters, parameterDecoratorsContainPrivateIdentifierInExpression))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function transformDecoratorsOfClassElements(node, members) {
|
|
let decorationStatements = [];
|
|
addClassElementDecorationStatements(decorationStatements, node, false);
|
|
addClassElementDecorationStatements(decorationStatements, node, true);
|
|
if (hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node)) {
|
|
members = setTextRange(factory2.createNodeArray([
|
|
...members,
|
|
factory2.createClassStaticBlockDeclaration(
|
|
factory2.createBlock(decorationStatements, true)
|
|
)
|
|
]), members);
|
|
decorationStatements = void 0;
|
|
}
|
|
return { decorationStatements, members };
|
|
}
|
|
function transformClassDeclarationWithoutClassDecorators(node, name) {
|
|
const modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, visitor, isHeritageClause);
|
|
let members = visitNodes2(node.members, visitor, isClassElement);
|
|
let decorationStatements = [];
|
|
({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
|
|
const updated = factory2.updateClassDeclaration(
|
|
node,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
return addRange([updated], decorationStatements);
|
|
}
|
|
function transformClassDeclarationWithClassDecorators(node, name) {
|
|
const location = moveRangePastModifiers(node);
|
|
const classAlias = getClassAliasIfNeeded(node);
|
|
const declName = languageVersion <= 2 /* ES2015 */ ? factory2.getInternalName(node, false, true) : factory2.getLocalName(node, false, true);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, visitor, isHeritageClause);
|
|
let members = visitNodes2(node.members, visitor, isClassElement);
|
|
let decorationStatements = [];
|
|
({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
|
|
const classExpression = factory2.createClassExpression(
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
setOriginalNode(classExpression, node);
|
|
setTextRange(classExpression, location);
|
|
const statement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
declName,
|
|
void 0,
|
|
void 0,
|
|
classAlias ? factory2.createAssignment(classAlias, classExpression) : classExpression
|
|
)
|
|
], 1 /* Let */)
|
|
);
|
|
setOriginalNode(statement, node);
|
|
setTextRange(statement, location);
|
|
setCommentRange(statement, node);
|
|
const statements = [statement];
|
|
addRange(statements, decorationStatements);
|
|
addConstructorDecorationStatement(statements, node);
|
|
return statements;
|
|
}
|
|
function visitClassExpression(node) {
|
|
return factory2.updateClassExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, visitor, isClassElement)
|
|
);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
visitNode(node.body, visitor, isBlock)
|
|
);
|
|
}
|
|
function finishClassElement(updated, original) {
|
|
if (updated !== original) {
|
|
setCommentRange(updated, original);
|
|
setSourceMapRange(updated, moveRangePastModifiers(original));
|
|
}
|
|
return updated;
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
return finishClassElement(factory2.updateMethodDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
return finishClassElement(factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
return finishClassElement(factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitPropertyDeclaration(node) {
|
|
if (node.flags & 16777216 /* Ambient */ || hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
return void 0;
|
|
}
|
|
return finishClassElement(factory2.updatePropertyDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
), node);
|
|
}
|
|
function visitParameterDeclaration(node) {
|
|
const updated = factory2.updateParameterDeclaration(
|
|
node,
|
|
elideNodes(factory2, node.modifiers),
|
|
node.dotDotDotToken,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (updated !== node) {
|
|
setCommentRange(updated, node);
|
|
setTextRange(updated, moveRangePastModifiers(node));
|
|
setSourceMapRange(updated, moveRangePastModifiers(node));
|
|
setEmitFlags(updated.name, 64 /* NoTrailingSourceMap */);
|
|
}
|
|
return updated;
|
|
}
|
|
function transformAllDecoratorsOfDeclaration(allDecorators) {
|
|
if (!allDecorators) {
|
|
return void 0;
|
|
}
|
|
const decoratorExpressions = [];
|
|
addRange(decoratorExpressions, map(allDecorators.decorators, transformDecorator));
|
|
addRange(decoratorExpressions, flatMap(allDecorators.parameters, transformDecoratorsOfParameter));
|
|
return decoratorExpressions;
|
|
}
|
|
function addClassElementDecorationStatements(statements, node, isStatic2) {
|
|
addRange(statements, map(generateClassElementDecorationExpressions(node, isStatic2), (expr) => factory2.createExpressionStatement(expr)));
|
|
}
|
|
function isDecoratedClassElement(member, isStaticElement, parent) {
|
|
return nodeOrChildIsDecorated(member, parent) && isStaticElement === isStatic(member);
|
|
}
|
|
function getDecoratedClassElements(node, isStatic2) {
|
|
return filter(node.members, (m) => isDecoratedClassElement(m, isStatic2, node));
|
|
}
|
|
function generateClassElementDecorationExpressions(node, isStatic2) {
|
|
const members = getDecoratedClassElements(node, isStatic2);
|
|
let expressions;
|
|
for (const member of members) {
|
|
expressions = append(expressions, generateClassElementDecorationExpression(node, member));
|
|
}
|
|
return expressions;
|
|
}
|
|
function generateClassElementDecorationExpression(node, member) {
|
|
const allDecorators = getAllDecoratorsOfClassElement(member, node);
|
|
const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
|
|
if (!decoratorExpressions) {
|
|
return void 0;
|
|
}
|
|
const prefix = getClassMemberPrefix(node, member);
|
|
const memberName = getExpressionForPropertyName(member, !hasSyntacticModifier(member, 2 /* Ambient */));
|
|
const descriptor = languageVersion > 0 /* ES3 */ ? isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull() : void 0;
|
|
const helper = emitHelpers().createDecorateHelper(
|
|
decoratorExpressions,
|
|
prefix,
|
|
memberName,
|
|
descriptor
|
|
);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
setSourceMapRange(helper, moveRangePastModifiers(member));
|
|
return helper;
|
|
}
|
|
function addConstructorDecorationStatement(statements, node) {
|
|
const expression = generateConstructorDecorationExpression(node);
|
|
if (expression) {
|
|
statements.push(setOriginalNode(factory2.createExpressionStatement(expression), node));
|
|
}
|
|
}
|
|
function generateConstructorDecorationExpression(node) {
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
|
|
if (!decoratorExpressions) {
|
|
return void 0;
|
|
}
|
|
const classAlias = classAliases && classAliases[getOriginalNodeId(node)];
|
|
const localName = languageVersion <= 2 /* ES2015 */ ? factory2.getInternalName(node, false, true) : factory2.getLocalName(node, false, true);
|
|
const decorate = emitHelpers().createDecorateHelper(decoratorExpressions, localName);
|
|
const expression = factory2.createAssignment(localName, classAlias ? factory2.createAssignment(classAlias, decorate) : decorate);
|
|
setEmitFlags(expression, 3072 /* NoComments */);
|
|
setSourceMapRange(expression, moveRangePastModifiers(node));
|
|
return expression;
|
|
}
|
|
function transformDecorator(decorator) {
|
|
return visitNode(decorator.expression, visitor, isExpression);
|
|
}
|
|
function transformDecoratorsOfParameter(decorators, parameterOffset) {
|
|
let expressions;
|
|
if (decorators) {
|
|
expressions = [];
|
|
for (const decorator of decorators) {
|
|
const helper = emitHelpers().createParamHelper(
|
|
transformDecorator(decorator),
|
|
parameterOffset
|
|
);
|
|
setTextRange(helper, decorator.expression);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
expressions.push(helper);
|
|
}
|
|
}
|
|
return expressions;
|
|
}
|
|
function getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
|
|
const name = member.name;
|
|
if (isPrivateIdentifier(name)) {
|
|
return factory2.createIdentifier("");
|
|
} else if (isComputedPropertyName(name)) {
|
|
return generateNameForComputedPropertyName && !isSimpleInlineableExpression(name.expression) ? factory2.getGeneratedNameForNode(name) : name.expression;
|
|
} else if (isIdentifier(name)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return factory2.cloneNode(name);
|
|
}
|
|
}
|
|
function enableSubstitutionForClassAliases() {
|
|
if (!classAliases) {
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
classAliases = [];
|
|
}
|
|
}
|
|
function getClassAliasIfNeeded(node) {
|
|
if (resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */) {
|
|
enableSubstitutionForClassAliases();
|
|
const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
|
|
classAliases[getOriginalNodeId(node)] = classAlias;
|
|
hoistVariableDeclaration(classAlias);
|
|
return classAlias;
|
|
}
|
|
}
|
|
function getClassPrototype(node) {
|
|
return factory2.createPropertyAccessExpression(factory2.getDeclarationName(node), "prototype");
|
|
}
|
|
function getClassMemberPrefix(node, member) {
|
|
return isStatic(member) ? factory2.getDeclarationName(node) : getClassPrototype(node);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2;
|
|
return (_a2 = trySubstituteClassAlias(node)) != null ? _a2 : node;
|
|
}
|
|
function trySubstituteClassAlias(node) {
|
|
if (classAliases) {
|
|
if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
|
|
const declaration = resolver.getReferencedValueDeclaration(node);
|
|
if (declaration) {
|
|
const classAlias = classAliases[declaration.id];
|
|
if (classAlias) {
|
|
const clone2 = factory2.cloneNode(classAlias);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2017.ts
|
|
function transformES2017(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
let enabledSubstitutions;
|
|
let enclosingSuperContainerFlags = 0;
|
|
let enclosingFunctionParameterNames;
|
|
let capturedSuperProperties;
|
|
let hasSuperElementAccess;
|
|
const substitutedSuperAccessors = [];
|
|
let contextFlags = 0 /* None */;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
setContextFlag(1 /* NonTopLevel */, false);
|
|
setContextFlag(2 /* HasLexicalThis */, !isEffectiveStrictModeSourceFile(node, compilerOptions));
|
|
const visited = visitEachChild(node, visitor, context);
|
|
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 /* NonTopLevel */);
|
|
}
|
|
function inHasLexicalThisContext() {
|
|
return inContext(2 /* HasLexicalThis */);
|
|
}
|
|
function doWithContext(flags, cb, value) {
|
|
const contextFlagsToSet = flags & ~contextFlags;
|
|
if (contextFlagsToSet) {
|
|
setContextFlag(contextFlagsToSet, true);
|
|
const result = cb(value);
|
|
setContextFlag(contextFlagsToSet, false);
|
|
return result;
|
|
}
|
|
return cb(value);
|
|
}
|
|
function visitDefault(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 256 /* ContainsES2017 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 132 /* AsyncKeyword */:
|
|
return void 0;
|
|
case 220 /* AwaitExpression */:
|
|
return visitAwaitExpression(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitMethodDeclaration, node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitFunctionDeclaration, node);
|
|
case 215 /* FunctionExpression */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitFunctionExpression, node);
|
|
case 216 /* ArrowFunction */:
|
|
return doWithContext(1 /* NonTopLevel */, visitArrowFunction, node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === 106 /* SuperKeyword */) {
|
|
capturedSuperProperties.add(node.name.escapedText);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 209 /* ElementAccessExpression */:
|
|
if (capturedSuperProperties && node.expression.kind === 106 /* SuperKeyword */) {
|
|
hasSuperElementAccess = true;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 174 /* GetAccessor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitGetAccessorDeclaration, node);
|
|
case 175 /* SetAccessor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitSetAccessorDeclaration, node);
|
|
case 173 /* Constructor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitConstructorDeclaration, node);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitDefault, node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function asyncBodyVisitor(node) {
|
|
if (isNodeWithPossibleHoistedDeclaration(node)) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatementInAsyncBody(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatementInAsyncBody(node);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatementInAsyncBody(node);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatementInAsyncBody(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClauseInAsyncBody(node);
|
|
case 238 /* Block */:
|
|
case 252 /* SwitchStatement */:
|
|
case 266 /* CaseBlock */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 255 /* TryStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 253 /* LabeledStatement */:
|
|
return visitEachChild(node, asyncBodyVisitor, context);
|
|
default:
|
|
return Debug.assertNever(node, "Unhandled node.");
|
|
}
|
|
}
|
|
return visitor(node);
|
|
}
|
|
function visitCatchClauseInAsyncBody(node) {
|
|
const catchClauseNames = /* @__PURE__ */ new Set();
|
|
recordDeclarationName(node.variableDeclaration, catchClauseNames);
|
|
let catchClauseUnshadowedNames;
|
|
catchClauseNames.forEach((_, escapedName) => {
|
|
if (enclosingFunctionParameterNames.has(escapedName)) {
|
|
if (!catchClauseUnshadowedNames) {
|
|
catchClauseUnshadowedNames = new Set(enclosingFunctionParameterNames);
|
|
}
|
|
catchClauseUnshadowedNames.delete(escapedName);
|
|
}
|
|
});
|
|
if (catchClauseUnshadowedNames) {
|
|
const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
|
|
enclosingFunctionParameterNames = catchClauseUnshadowedNames;
|
|
const result = visitEachChild(node, asyncBodyVisitor, context);
|
|
enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames;
|
|
return result;
|
|
} else {
|
|
return visitEachChild(node, asyncBodyVisitor, context);
|
|
}
|
|
}
|
|
function visitVariableStatementInAsyncBody(node) {
|
|
if (isVariableDeclarationListWithCollidingName(node.declarationList)) {
|
|
const expression = visitVariableDeclarationListWithCollidingNames(node.declarationList, false);
|
|
return expression ? factory2.createExpressionStatement(expression) : void 0;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForInStatementInAsyncBody(node) {
|
|
return factory2.updateForInStatement(
|
|
node,
|
|
isVariableDeclarationListWithCollidingName(node.initializer) ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitForOfStatementInAsyncBody(node) {
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
visitNode(node.awaitModifier, visitor, isToken),
|
|
isVariableDeclarationListWithCollidingName(node.initializer) ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitForStatementInAsyncBody(node) {
|
|
const initializer = node.initializer;
|
|
return factory2.updateForStatement(
|
|
node,
|
|
isVariableDeclarationListWithCollidingName(initializer) ? visitVariableDeclarationListWithCollidingNames(initializer, false) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitAwaitExpression(node) {
|
|
if (inTopLevelContext()) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
return factory2.updateMethodDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
return factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
return factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
return factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
return factory2.updateFunctionExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function visitArrowFunction(node) {
|
|
return factory2.updateArrowFunction(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function recordDeclarationName({ name }, names) {
|
|
if (isIdentifier(name)) {
|
|
names.add(name.escapedText);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
recordDeclarationName(element, names);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isVariableDeclarationListWithCollidingName(node) {
|
|
return !!node && isVariableDeclarationList(node) && !(node.flags & 3 /* BlockScoped */) && node.declarations.some(collidesWithParameterName);
|
|
}
|
|
function visitVariableDeclarationListWithCollidingNames(node, hasReceiver) {
|
|
hoistVariableDeclarationList(node);
|
|
const variables = getInitializedVariables(node);
|
|
if (variables.length === 0) {
|
|
if (hasReceiver) {
|
|
return visitNode(factory2.converters.convertToAssignmentElementTarget(node.declarations[0].name), visitor, isExpression);
|
|
}
|
|
return void 0;
|
|
}
|
|
return factory2.inlineExpressions(map(variables, transformInitializedVariable));
|
|
}
|
|
function hoistVariableDeclarationList(node) {
|
|
forEach(node.declarations, hoistVariable);
|
|
}
|
|
function hoistVariable({ name }) {
|
|
if (isIdentifier(name)) {
|
|
hoistVariableDeclaration(name);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
hoistVariable(element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
const converted = setSourceMapRange(
|
|
factory2.createAssignment(
|
|
factory2.converters.convertToAssignmentElementTarget(node.name),
|
|
node.initializer
|
|
),
|
|
node
|
|
);
|
|
return visitNode(converted, visitor, isExpression);
|
|
}
|
|
function collidesWithParameterName({ name }) {
|
|
if (isIdentifier(name)) {
|
|
return enclosingFunctionParameterNames.has(name.escapedText);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element) && collidesWithParameterName(element)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function transformMethodBody(node) {
|
|
Debug.assertIsDefined(node.body);
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
let updated = visitFunctionBody(node.body, visitor, context);
|
|
const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
if (capturedSuperProperties.size) {
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
const statements = updated.statements.slice();
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
updated = factory2.updateBlock(updated, statements);
|
|
}
|
|
if (hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(updated, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(updated, asyncSuperHelper);
|
|
}
|
|
}
|
|
}
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
return updated;
|
|
}
|
|
function transformAsyncFunctionBody(node) {
|
|
resumeLexicalEnvironment();
|
|
const original = getOriginalNode(node, isFunctionLike);
|
|
const nodeType = original.type;
|
|
const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
|
|
const isArrowFunction2 = node.kind === 216 /* ArrowFunction */;
|
|
const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
|
|
const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
|
|
enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
|
|
for (const parameter of node.parameters) {
|
|
recordDeclarationName(parameter, enclosingFunctionParameterNames);
|
|
}
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
if (!isArrowFunction2) {
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
}
|
|
let result;
|
|
if (!isArrowFunction2) {
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.body.statements, statements, false, visitor);
|
|
statements.push(
|
|
factory2.createReturnStatement(
|
|
emitHelpers().createAwaiterHelper(
|
|
inHasLexicalThisContext(),
|
|
hasLexicalArguments,
|
|
promiseConstructor,
|
|
transformAsyncFunctionBodyWorker(node.body, statementOffset)
|
|
)
|
|
)
|
|
);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
if (capturedSuperProperties.size) {
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
}
|
|
}
|
|
const block = factory2.createBlock(statements, true);
|
|
setTextRange(block, node.body);
|
|
if (emitSuperHelpers && hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(block, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(block, asyncSuperHelper);
|
|
}
|
|
}
|
|
result = block;
|
|
} else {
|
|
const expression = emitHelpers().createAwaiterHelper(
|
|
inHasLexicalThisContext(),
|
|
hasLexicalArguments,
|
|
promiseConstructor,
|
|
transformAsyncFunctionBodyWorker(node.body)
|
|
);
|
|
const declarations = endLexicalEnvironment();
|
|
if (some(declarations)) {
|
|
const block = factory2.converters.convertToFunctionBlock(expression);
|
|
result = factory2.updateBlock(block, setTextRange(factory2.createNodeArray(concatenate(declarations, block.statements)), block.statements));
|
|
} else {
|
|
result = expression;
|
|
}
|
|
}
|
|
enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames;
|
|
if (!isArrowFunction2) {
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
}
|
|
return result;
|
|
}
|
|
function transformAsyncFunctionBodyWorker(body, start) {
|
|
if (isBlock(body)) {
|
|
return factory2.updateBlock(body, visitNodes2(body.statements, asyncBodyVisitor, isStatement, start));
|
|
} else {
|
|
return factory2.converters.convertToFunctionBlock(visitNode(body, asyncBodyVisitor, isConciseBody));
|
|
}
|
|
}
|
|
function getPromiseConstructor(type) {
|
|
const typeName = type && getEntityNameFromTypeNode(type);
|
|
if (typeName && isEntityName(typeName)) {
|
|
const serializationKind = resolver.getTypeReferenceSerializationKind(typeName);
|
|
if (serializationKind === 1 /* TypeWithConstructSignatureAndValue */ || serializationKind === 0 /* Unknown */) {
|
|
return typeName;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function enableSubstitutionForAsyncMethodsWithSuper() {
|
|
if ((enabledSubstitutions & 1 /* AsyncMethodsWithSuper */) === 0) {
|
|
enabledSubstitutions |= 1 /* AsyncMethodsWithSuper */;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
context.enableEmitNotification(260 /* ClassDeclaration */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(240 /* VariableStatement */);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
|
|
const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
|
|
if (superContainerFlags !== enclosingSuperContainerFlags) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = superContainerFlags;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
} else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */ && enclosingSuperContainerFlags) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
node.name
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return createSuperElementAccessInAsyncMethod(
|
|
node.argumentExpression,
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
const expression = node.expression;
|
|
if (isSuperProperty(expression)) {
|
|
const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression);
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(argumentExpression, "call"),
|
|
void 0,
|
|
[
|
|
factory2.createThis(),
|
|
...node.arguments
|
|
]
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function isSuperContainer(node) {
|
|
const kind = node.kind;
|
|
return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
|
|
if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createCallExpression(
|
|
factory2.createUniqueName("_superIndex", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
"value"
|
|
),
|
|
location
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createUniqueName("_superIndex", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
location
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function createSuperAccessVariableStatement(factory2, resolver, node, names) {
|
|
const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
|
|
const accessors = [];
|
|
names.forEach((_, key) => {
|
|
const name = unescapeLeadingUnderscores(key);
|
|
const getterAndSetter = [];
|
|
getterAndSetter.push(factory2.createPropertyAssignment(
|
|
"get",
|
|
factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(
|
|
factory2.createSuper(),
|
|
8 /* NoSubstitution */
|
|
),
|
|
name
|
|
),
|
|
8 /* NoSubstitution */
|
|
)
|
|
)
|
|
));
|
|
if (hasBinding) {
|
|
getterAndSetter.push(
|
|
factory2.createPropertyAssignment(
|
|
"set",
|
|
factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"v",
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)
|
|
],
|
|
void 0,
|
|
void 0,
|
|
factory2.createAssignment(
|
|
setEmitFlags(
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(
|
|
factory2.createSuper(),
|
|
8 /* NoSubstitution */
|
|
),
|
|
name
|
|
),
|
|
8 /* NoSubstitution */
|
|
),
|
|
factory2.createIdentifier("v")
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
accessors.push(
|
|
factory2.createPropertyAssignment(
|
|
name,
|
|
factory2.createObjectLiteralExpression(getterAndSetter)
|
|
)
|
|
);
|
|
});
|
|
return factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("Object"),
|
|
"create"
|
|
),
|
|
void 0,
|
|
[
|
|
factory2.createNull(),
|
|
factory2.createObjectLiteralExpression(accessors, true)
|
|
]
|
|
)
|
|
)
|
|
],
|
|
2 /* Const */
|
|
)
|
|
);
|
|
}
|
|
|
|
// src/compiler/transformers/es2018.ts
|
|
function transformES2018(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let exportedVariableStatement = false;
|
|
let enabledSubstitutions;
|
|
let enclosingFunctionFlags;
|
|
let parametersWithPrecedingObjectRestOrSpread;
|
|
let enclosingSuperContainerFlags = 0;
|
|
let hierarchyFacts = 0;
|
|
let currentSourceFile;
|
|
let taggedTemplateStringDeclarations;
|
|
let capturedSuperProperties;
|
|
let hasSuperElementAccess;
|
|
const substitutedSuperAccessors = [];
|
|
return chainBundle(context, transformSourceFile);
|
|
function affectsSubtree(excludeFacts, includeFacts) {
|
|
return hierarchyFacts !== (hierarchyFacts & ~excludeFacts | includeFacts);
|
|
}
|
|
function enterSubtree(excludeFacts, includeFacts) {
|
|
const ancestorFacts = hierarchyFacts;
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 3 /* AncestorFactsMask */;
|
|
return ancestorFacts;
|
|
}
|
|
function exitSubtree(ancestorFacts) {
|
|
hierarchyFacts = ancestorFacts;
|
|
}
|
|
function recordTaggedTemplateString(temp) {
|
|
taggedTemplateStringDeclarations = append(
|
|
taggedTemplateStringDeclarations,
|
|
factory2.createVariableDeclaration(temp)
|
|
);
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const visited = visitSourceFile(node);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
taggedTemplateStringDeclarations = void 0;
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function visitorWithUnusedExpressionResult(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function visitorNoAsyncModifier(node) {
|
|
if (node.kind === 132 /* AsyncKeyword */) {
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function doWithHierarchyFacts(cb, value, excludeFacts, includeFacts) {
|
|
if (affectsSubtree(excludeFacts, includeFacts)) {
|
|
const ancestorFacts = enterSubtree(excludeFacts, includeFacts);
|
|
const result = cb(value);
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
return cb(value);
|
|
}
|
|
function visitDefault(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitorWorker(node, expressionResultIsUnused2) {
|
|
if ((node.transformFlags & 128 /* ContainsES2018 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 220 /* AwaitExpression */:
|
|
return visitAwaitExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, expressionResultIsUnused2);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node, expressionResultIsUnused2);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 246 /* ForInStatement */:
|
|
return doWithHierarchyFacts(
|
|
visitDefault,
|
|
node,
|
|
0 /* IterationStatementExcludes */,
|
|
2 /* IterationStatementIncludes */
|
|
);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, void 0);
|
|
case 245 /* ForStatement */:
|
|
return doWithHierarchyFacts(
|
|
visitForStatement,
|
|
node,
|
|
0 /* IterationStatementExcludes */,
|
|
2 /* IterationStatementIncludes */
|
|
);
|
|
case 219 /* VoidExpression */:
|
|
return visitVoidExpression(node);
|
|
case 173 /* Constructor */:
|
|
return doWithHierarchyFacts(
|
|
visitConstructorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 171 /* MethodDeclaration */:
|
|
return doWithHierarchyFacts(
|
|
visitMethodDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 174 /* GetAccessor */:
|
|
return doWithHierarchyFacts(
|
|
visitGetAccessorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 175 /* SetAccessor */:
|
|
return doWithHierarchyFacts(
|
|
visitSetAccessorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 259 /* FunctionDeclaration */:
|
|
return doWithHierarchyFacts(
|
|
visitFunctionDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 215 /* FunctionExpression */:
|
|
return doWithHierarchyFacts(
|
|
visitFunctionExpression,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 216 /* ArrowFunction */:
|
|
return doWithHierarchyFacts(
|
|
visitArrowFunction,
|
|
node,
|
|
2 /* ArrowFunctionExcludes */,
|
|
0 /* ArrowFunctionIncludes */
|
|
);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, expressionResultIsUnused2);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === 106 /* SuperKeyword */) {
|
|
capturedSuperProperties.add(node.name.escapedText);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 209 /* ElementAccessExpression */:
|
|
if (capturedSuperProperties && node.expression.kind === 106 /* SuperKeyword */) {
|
|
hasSuperElementAccess = true;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return doWithHierarchyFacts(
|
|
visitDefault,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitAwaitExpression(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(void 0, emitHelpers().createAwaitHelper(visitNode(node.expression, visitor, isExpression))),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
if (node.asteriskToken) {
|
|
const expression = visitNode(Debug.checkDefined(node.expression), visitor, isExpression);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
emitHelpers().createAwaitHelper(
|
|
factory2.updateYieldExpression(
|
|
node,
|
|
node.asteriskToken,
|
|
setTextRange(
|
|
emitHelpers().createAsyncDelegatorHelper(
|
|
setTextRange(
|
|
emitHelpers().createAsyncValuesHelper(expression),
|
|
expression
|
|
)
|
|
),
|
|
expression
|
|
)
|
|
)
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
createDownlevelAwait(
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
return factory2.updateReturnStatement(node, createDownlevelAwait(
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
));
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */) {
|
|
const statement = unwrapInnermostStatementOfLabel(node);
|
|
if (statement.kind === 247 /* ForOfStatement */ && statement.awaitModifier) {
|
|
return visitForOfStatement(statement, node);
|
|
}
|
|
return factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock), node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function chunkObjectLiteralElements(elements) {
|
|
let chunkObject;
|
|
const objects = [];
|
|
for (const e of elements) {
|
|
if (e.kind === 301 /* SpreadAssignment */) {
|
|
if (chunkObject) {
|
|
objects.push(factory2.createObjectLiteralExpression(chunkObject));
|
|
chunkObject = void 0;
|
|
}
|
|
const target = e.expression;
|
|
objects.push(visitNode(target, visitor, isExpression));
|
|
} else {
|
|
chunkObject = append(chunkObject, e.kind === 299 /* PropertyAssignment */ ? factory2.createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) : visitNode(e, visitor, isObjectLiteralElementLike));
|
|
}
|
|
}
|
|
if (chunkObject) {
|
|
objects.push(factory2.createObjectLiteralExpression(chunkObject));
|
|
}
|
|
return objects;
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
const objects = chunkObjectLiteralElements(node.properties);
|
|
if (objects.length && objects[0].kind !== 207 /* ObjectLiteralExpression */) {
|
|
objects.unshift(factory2.createObjectLiteralExpression());
|
|
}
|
|
let expression = objects[0];
|
|
if (objects.length > 1) {
|
|
for (let i = 1; i < objects.length; i++) {
|
|
expression = emitHelpers().createAssignHelper([expression, objects[i]]);
|
|
}
|
|
return expression;
|
|
} else {
|
|
return emitHelpers().createAssignHelper(objects);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitParenthesizedExpression(node, expressionResultIsUnused2) {
|
|
return visitEachChild(node, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, context);
|
|
}
|
|
function visitSourceFile(node) {
|
|
const ancestorFacts = enterSubtree(
|
|
2 /* SourceFileExcludes */,
|
|
isEffectiveStrictModeSourceFile(node, compilerOptions) ? 0 /* StrictModeSourceFileIncludes */ : 1 /* SourceFileIncludes */
|
|
);
|
|
exportedVariableStatement = false;
|
|
const visited = visitEachChild(node, visitor, context);
|
|
const statement = concatenate(visited.statements, taggedTemplateStringDeclarations && [
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(taggedTemplateStringDeclarations)
|
|
)
|
|
]);
|
|
const result = factory2.updateSourceFile(visited, setTextRange(factory2.createNodeArray(statement), node.statements));
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return processTaggedTemplateExpression(
|
|
context,
|
|
node,
|
|
visitor,
|
|
currentSourceFile,
|
|
recordTaggedTemplateString,
|
|
0 /* LiftRestriction */
|
|
);
|
|
}
|
|
function visitBinaryExpression(node, expressionResultIsUnused2) {
|
|
if (isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
!expressionResultIsUnused2
|
|
);
|
|
}
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, visitorWithUnusedExpressionResult, isExpression),
|
|
node.operatorToken,
|
|
visitNode(node.right, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaListExpression(node, expressionResultIsUnused2) {
|
|
if (expressionResultIsUnused2) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
let result;
|
|
for (let i = 0; i < node.elements.length; i++) {
|
|
const element = node.elements[i];
|
|
const visited = visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, isExpression);
|
|
if (result || visited !== element) {
|
|
result || (result = node.elements.slice(0, i));
|
|
result.push(visited);
|
|
}
|
|
}
|
|
const elements = result ? setTextRange(factory2.createNodeArray(result), node.elements) : node.elements;
|
|
return factory2.updateCommaListExpression(node, elements);
|
|
}
|
|
function visitCatchClause(node) {
|
|
if (node.variableDeclaration && isBindingPattern(node.variableDeclaration.name) && node.variableDeclaration.name.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
const name = factory2.getGeneratedNameForNode(node.variableDeclaration.name);
|
|
const updatedDecl = factory2.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, void 0, void 0, name);
|
|
const visitedBindings = flattenDestructuringBinding(updatedDecl, visitor, context, 1 /* ObjectRest */);
|
|
let block = visitNode(node.block, visitor, isBlock);
|
|
if (some(visitedBindings)) {
|
|
block = factory2.updateBlock(block, [
|
|
factory2.createVariableStatement(void 0, visitedBindings),
|
|
...block.statements
|
|
]);
|
|
}
|
|
return factory2.updateCatchClause(
|
|
node,
|
|
factory2.updateVariableDeclaration(node.variableDeclaration, name, void 0, void 0, void 0),
|
|
block
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
const savedExportedVariableStatement = exportedVariableStatement;
|
|
exportedVariableStatement = true;
|
|
const visited = visitEachChild(node, visitor, context);
|
|
exportedVariableStatement = savedExportedVariableStatement;
|
|
return visited;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
if (exportedVariableStatement) {
|
|
const savedExportedVariableStatement = exportedVariableStatement;
|
|
exportedVariableStatement = false;
|
|
const visited = visitVariableDeclarationWorker(node, true);
|
|
exportedVariableStatement = savedExportedVariableStatement;
|
|
return visited;
|
|
}
|
|
return visitVariableDeclarationWorker(node, false);
|
|
}
|
|
function visitVariableDeclarationWorker(node, exportedVariableStatement2) {
|
|
if (isBindingPattern(node.name) && node.name.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return flattenDestructuringBinding(
|
|
node,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
void 0,
|
|
exportedVariableStatement2
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitVoidExpression(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitForOfStatement(node, outermostLabeledStatement) {
|
|
const ancestorFacts = enterSubtree(0 /* IterationStatementExcludes */, 2 /* IterationStatementIncludes */);
|
|
if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
node = transformForOfStatementWithObjectRest(node);
|
|
}
|
|
const result = node.awaitModifier ? transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) : factory2.restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement);
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
function transformForOfStatementWithObjectRest(node) {
|
|
const initializerWithoutParens = skipParentheses(node.initializer);
|
|
if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) {
|
|
let bodyLocation;
|
|
let statementsLocation;
|
|
const temp = factory2.createTempVariable(void 0);
|
|
const statements = [createForOfBindingStatement(factory2, initializerWithoutParens, temp)];
|
|
if (isBlock(node.statement)) {
|
|
addRange(statements, node.statement.statements);
|
|
bodyLocation = node.statement;
|
|
statementsLocation = node.statement.statements;
|
|
} else if (node.statement) {
|
|
append(statements, node.statement);
|
|
bodyLocation = node.statement;
|
|
statementsLocation = node.statement;
|
|
}
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
node.awaitModifier,
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
setTextRange(factory2.createVariableDeclaration(temp), node.initializer)
|
|
],
|
|
1 /* Let */
|
|
),
|
|
node.initializer
|
|
),
|
|
node.expression,
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), statementsLocation),
|
|
true
|
|
),
|
|
bodyLocation
|
|
)
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function convertForOfStatementHead(node, boundValue, nonUserCode) {
|
|
const value = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const iteratorValueExpression = factory2.createAssignment(value, boundValue);
|
|
const iteratorValueStatement = factory2.createExpressionStatement(iteratorValueExpression);
|
|
setSourceMapRange(iteratorValueStatement, node.expression);
|
|
const exitNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createFalse());
|
|
const exitNonUserCodeStatement = factory2.createExpressionStatement(exitNonUserCodeExpression);
|
|
setSourceMapRange(exitNonUserCodeStatement, node.expression);
|
|
const enterNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createTrue());
|
|
const enterNonUserCodeStatement = factory2.createExpressionStatement(enterNonUserCodeExpression);
|
|
setSourceMapRange(exitNonUserCodeStatement, node.expression);
|
|
const statements = [];
|
|
const binding = createForOfBindingStatement(factory2, node.initializer, value);
|
|
statements.push(visitNode(binding, visitor, isStatement));
|
|
let bodyLocation;
|
|
let statementsLocation;
|
|
const statement = visitIterationBody(node.statement, visitor, context);
|
|
if (isBlock(statement)) {
|
|
addRange(statements, statement.statements);
|
|
bodyLocation = statement;
|
|
statementsLocation = statement.statements;
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
const body = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), statementsLocation),
|
|
true
|
|
),
|
|
bodyLocation
|
|
),
|
|
96 /* NoSourceMap */ | 768 /* NoTokenSourceMaps */
|
|
);
|
|
return factory2.createBlock([
|
|
iteratorValueStatement,
|
|
exitNonUserCodeStatement,
|
|
factory2.createTryStatement(
|
|
body,
|
|
void 0,
|
|
factory2.createBlock([
|
|
enterNonUserCodeStatement
|
|
])
|
|
)
|
|
]);
|
|
}
|
|
function createDownlevelAwait(expression) {
|
|
return enclosingFunctionFlags & 1 /* Generator */ ? factory2.createYieldExpression(void 0, emitHelpers().createAwaitHelper(expression)) : factory2.createAwaitExpression(expression);
|
|
}
|
|
function transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const iterator = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
const result = isIdentifier(expression) ? factory2.getGeneratedNameForNode(iterator) : factory2.createTempVariable(void 0);
|
|
const nonUserCode = factory2.createTempVariable(void 0);
|
|
const done = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const errorRecord = factory2.createUniqueName("e");
|
|
const catchVariable = factory2.getGeneratedNameForNode(errorRecord);
|
|
const returnMethod = factory2.createTempVariable(void 0);
|
|
const callValues = setTextRange(emitHelpers().createAsyncValuesHelper(expression), node.expression);
|
|
const callNext = factory2.createCallExpression(factory2.createPropertyAccessExpression(iterator, "next"), void 0, []);
|
|
const getDone = factory2.createPropertyAccessExpression(result, "done");
|
|
const getValue = factory2.createPropertyAccessExpression(result, "value");
|
|
const callReturn = factory2.createFunctionCallCall(returnMethod, iterator, []);
|
|
hoistVariableDeclaration(errorRecord);
|
|
hoistVariableDeclaration(returnMethod);
|
|
const initializer = ancestorFacts & 2 /* IterationContainer */ ? factory2.inlineExpressions([factory2.createAssignment(errorRecord, factory2.createVoidZero()), callValues]) : callValues;
|
|
const forStatement = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(nonUserCode, void 0, void 0, factory2.createTrue()),
|
|
setTextRange(factory2.createVariableDeclaration(iterator, void 0, void 0, initializer), node.expression),
|
|
factory2.createVariableDeclaration(result)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
factory2.inlineExpressions([
|
|
factory2.createAssignment(result, createDownlevelAwait(callNext)),
|
|
factory2.createAssignment(done, getDone),
|
|
factory2.createLogicalNot(done)
|
|
]),
|
|
void 0,
|
|
convertForOfStatementHead(node, getValue, nonUserCode)
|
|
),
|
|
node
|
|
),
|
|
512 /* NoTokenTrailingSourceMaps */
|
|
);
|
|
setOriginalNode(forStatement, node);
|
|
return factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
factory2.restoreEnclosingLabel(
|
|
forStatement,
|
|
outermostLabeledStatement
|
|
)
|
|
]),
|
|
factory2.createCatchClause(
|
|
factory2.createVariableDeclaration(catchVariable),
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
errorRecord,
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("error", catchVariable)
|
|
])
|
|
)
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalNot(nonUserCode),
|
|
factory2.createLogicalNot(done)
|
|
),
|
|
factory2.createAssignment(
|
|
returnMethod,
|
|
factory2.createPropertyAccessExpression(iterator, "return")
|
|
)
|
|
),
|
|
factory2.createExpressionStatement(createDownlevelAwait(callReturn))
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
errorRecord,
|
|
factory2.createThrowStatement(
|
|
factory2.createPropertyAccessExpression(errorRecord, "error")
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function parameterVisitor(node) {
|
|
Debug.assertNode(node, isParameter);
|
|
return visitParameter(node);
|
|
}
|
|
function visitParameter(node) {
|
|
if (parametersWithPrecedingObjectRestOrSpread == null ? void 0 : parametersWithPrecedingObjectRestOrSpread.has(node)) {
|
|
return factory2.updateParameterDeclaration(
|
|
node,
|
|
void 0,
|
|
node.dotDotDotToken,
|
|
isBindingPattern(node.name) ? factory2.getGeneratedNameForNode(node) : node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return factory2.updateParameterDeclaration(
|
|
node,
|
|
void 0,
|
|
node.dotDotDotToken,
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function collectParametersWithPrecedingObjectRestOrSpread(node) {
|
|
let parameters;
|
|
for (const parameter of node.parameters) {
|
|
if (parameters) {
|
|
parameters.add(parameter);
|
|
} else if (parameter.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
parameters = /* @__PURE__ */ new Set();
|
|
}
|
|
}
|
|
return parameters;
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateConstructorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateMethodDeclaration(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifierLike) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNode(void 0, visitor, isToken),
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateFunctionDeclaration(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifier) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateArrowFunction(
|
|
node,
|
|
node.modifiers,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateFunctionExpression(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifier) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function transformAsyncGeneratorFunctionBody(node) {
|
|
resumeLexicalEnvironment();
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.body.statements, statements, false, visitor);
|
|
appendObjectRestAssignmentsIfNeeded(statements, node);
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
const returnStatement = factory2.createReturnStatement(
|
|
emitHelpers().createAsyncGeneratorHelper(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
node.name && factory2.getGeneratedNameForNode(node.name),
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.updateBlock(
|
|
node.body,
|
|
visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset)
|
|
)
|
|
),
|
|
!!(hierarchyFacts & 1 /* HasLexicalThis */)
|
|
)
|
|
);
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
}
|
|
statements.push(returnStatement);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const block = factory2.updateBlock(node.body, statements);
|
|
if (emitSuperHelpers && hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(block, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(block, asyncSuperHelper);
|
|
}
|
|
}
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
return block;
|
|
}
|
|
function transformFunctionBody(node) {
|
|
var _a2;
|
|
resumeLexicalEnvironment();
|
|
let statementOffset = 0;
|
|
const statements = [];
|
|
const body = (_a2 = visitNode(node.body, visitor, isConciseBody)) != null ? _a2 : factory2.createBlock([]);
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyPrologue(body.statements, statements, false, visitor);
|
|
}
|
|
addRange(statements, appendObjectRestAssignmentsIfNeeded(void 0, node));
|
|
const leadingStatements = endLexicalEnvironment();
|
|
if (statementOffset > 0 || some(statements) || some(leadingStatements)) {
|
|
const block = factory2.converters.convertToFunctionBlock(body, true);
|
|
insertStatementsAfterStandardPrologue(statements, leadingStatements);
|
|
addRange(statements, block.statements.slice(statementOffset));
|
|
return factory2.updateBlock(block, setTextRange(factory2.createNodeArray(statements), block.statements));
|
|
}
|
|
return body;
|
|
}
|
|
function appendObjectRestAssignmentsIfNeeded(statements, node) {
|
|
let containsPrecedingObjectRestOrSpread = false;
|
|
for (const parameter of node.parameters) {
|
|
if (containsPrecedingObjectRestOrSpread) {
|
|
if (isBindingPattern(parameter.name)) {
|
|
if (parameter.name.elements.length > 0) {
|
|
const declarations = flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
);
|
|
if (some(declarations)) {
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
const statement = factory2.createVariableStatement(void 0, declarationList);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.initializer) {
|
|
const name = factory2.getGeneratedNameForNode(parameter);
|
|
const initializer = visitNode(parameter.initializer, visitor, isExpression);
|
|
const assignment = factory2.createAssignment(name, initializer);
|
|
const statement = factory2.createExpressionStatement(assignment);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.initializer) {
|
|
const name = factory2.cloneNode(parameter.name);
|
|
setTextRange(name, parameter.name);
|
|
setEmitFlags(name, 96 /* NoSourceMap */);
|
|
const initializer = visitNode(parameter.initializer, visitor, isExpression);
|
|
addEmitFlags(initializer, 96 /* NoSourceMap */ | 3072 /* NoComments */);
|
|
const assignment = factory2.createAssignment(name, initializer);
|
|
setTextRange(assignment, parameter);
|
|
setEmitFlags(assignment, 3072 /* NoComments */);
|
|
const block = factory2.createBlock([factory2.createExpressionStatement(assignment)]);
|
|
setTextRange(block, parameter);
|
|
setEmitFlags(block, 1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */);
|
|
const typeCheck = factory2.createTypeCheck(factory2.cloneNode(parameter.name), "undefined");
|
|
const statement = factory2.createIfStatement(typeCheck, block);
|
|
startOnNewLine(statement);
|
|
setTextRange(statement, parameter);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2097152 /* CustomPrologue */ | 3072 /* NoComments */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
containsPrecedingObjectRestOrSpread = true;
|
|
const declarations = flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
false,
|
|
true
|
|
);
|
|
if (some(declarations)) {
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
const statement = factory2.createVariableStatement(void 0, declarationList);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function enableSubstitutionForAsyncMethodsWithSuper() {
|
|
if ((enabledSubstitutions & 1 /* AsyncMethodsWithSuper */) === 0) {
|
|
enabledSubstitutions |= 1 /* AsyncMethodsWithSuper */;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
context.enableEmitNotification(260 /* ClassDeclaration */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(240 /* VariableStatement */);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
|
|
const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
|
|
if (superContainerFlags !== enclosingSuperContainerFlags) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = superContainerFlags;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
} else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */ && enclosingSuperContainerFlags) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
node.name
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return createSuperElementAccessInAsyncMethod(
|
|
node.argumentExpression,
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
const expression = node.expression;
|
|
if (isSuperProperty(expression)) {
|
|
const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression);
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(argumentExpression, "call"),
|
|
void 0,
|
|
[
|
|
factory2.createThis(),
|
|
...node.arguments
|
|
]
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function isSuperContainer(node) {
|
|
const kind = node.kind;
|
|
return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
|
|
if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("_superIndex"),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
"value"
|
|
),
|
|
location
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("_superIndex"),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
location
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2019.ts
|
|
function transformES2019(context) {
|
|
const factory2 = context.factory;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 64 /* ContainsES2019 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitCatchClause(node) {
|
|
if (!node.variableDeclaration) {
|
|
return factory2.updateCatchClause(
|
|
node,
|
|
factory2.createVariableDeclaration(factory2.createTempVariable(void 0)),
|
|
visitNode(node.block, visitor, isBlock)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2020.ts
|
|
function transformES2020(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 32 /* ContainsES2020 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */: {
|
|
const updated = visitNonOptionalCallExpression(node, false);
|
|
Debug.assertNotNode(updated, isSyntheticReference);
|
|
return updated;
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (isOptionalChain(node)) {
|
|
const updated = visitOptionalExpression(node, false, false);
|
|
Debug.assertNotNode(updated, isSyntheticReference);
|
|
return updated;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 223 /* BinaryExpression */:
|
|
if (node.operatorToken.kind === 60 /* QuestionQuestionToken */) {
|
|
return transformNullishCoalescingExpression(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 217 /* DeleteExpression */:
|
|
return visitDeleteExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function flattenChain(chain) {
|
|
Debug.assertNotNode(chain, isNonNullChain);
|
|
const links = [chain];
|
|
while (!chain.questionDotToken && !isTaggedTemplateExpression(chain)) {
|
|
chain = cast(skipPartiallyEmittedExpressions(chain.expression), isOptionalChain);
|
|
Debug.assertNotNode(chain, isNonNullChain);
|
|
links.unshift(chain);
|
|
}
|
|
return { expression: chain.expression, chain: links };
|
|
}
|
|
function visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete) {
|
|
const expression = visitNonOptionalExpression(node.expression, captureThisArg, isDelete);
|
|
if (isSyntheticReference(expression)) {
|
|
return factory2.createSyntheticReferenceExpression(factory2.updateParenthesizedExpression(node, expression.expression), expression.thisArg);
|
|
}
|
|
return factory2.updateParenthesizedExpression(node, expression);
|
|
}
|
|
function visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete) {
|
|
if (isOptionalChain(node)) {
|
|
return visitOptionalExpression(node, captureThisArg, isDelete);
|
|
}
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
Debug.assertNotNode(expression, isSyntheticReference);
|
|
let thisArg;
|
|
if (captureThisArg) {
|
|
if (!isSimpleCopiableExpression(expression)) {
|
|
thisArg = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(thisArg, expression);
|
|
} else {
|
|
thisArg = expression;
|
|
}
|
|
}
|
|
expression = node.kind === 208 /* PropertyAccessExpression */ ? factory2.updatePropertyAccessExpression(node, expression, visitNode(node.name, visitor, isIdentifier)) : factory2.updateElementAccessExpression(node, expression, visitNode(node.argumentExpression, visitor, isExpression));
|
|
return thisArg ? factory2.createSyntheticReferenceExpression(expression, thisArg) : expression;
|
|
}
|
|
function visitNonOptionalCallExpression(node, captureThisArg) {
|
|
if (isOptionalChain(node)) {
|
|
return visitOptionalExpression(node, captureThisArg, false);
|
|
}
|
|
if (isParenthesizedExpression(node.expression) && isOptionalChain(skipParentheses(node.expression))) {
|
|
const expression = visitNonOptionalParenthesizedExpression(node.expression, true, false);
|
|
const args = visitNodes2(node.arguments, visitor, isExpression);
|
|
if (isSyntheticReference(expression)) {
|
|
return setTextRange(factory2.createFunctionCallCall(expression.expression, expression.thisArg, args), node);
|
|
}
|
|
return factory2.updateCallExpression(node, expression, void 0, args);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNonOptionalExpression(node, captureThisArg, isDelete) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
|
|
case 210 /* CallExpression */:
|
|
return visitNonOptionalCallExpression(node, captureThisArg);
|
|
default:
|
|
return visitNode(node, visitor, isExpression);
|
|
}
|
|
}
|
|
function visitOptionalExpression(node, captureThisArg, isDelete) {
|
|
const { expression, chain } = flattenChain(node);
|
|
const left = visitNonOptionalExpression(skipPartiallyEmittedExpressions(expression), isCallChain(chain[0]), false);
|
|
let leftThisArg = isSyntheticReference(left) ? left.thisArg : void 0;
|
|
let capturedLeft = isSyntheticReference(left) ? left.expression : left;
|
|
let leftExpression = factory2.restoreOuterExpressions(expression, capturedLeft, 8 /* PartiallyEmittedExpressions */);
|
|
if (!isSimpleCopiableExpression(capturedLeft)) {
|
|
capturedLeft = factory2.createTempVariable(hoistVariableDeclaration);
|
|
leftExpression = factory2.createAssignment(capturedLeft, leftExpression);
|
|
}
|
|
let rightExpression = capturedLeft;
|
|
let thisArg;
|
|
for (let i = 0; i < chain.length; i++) {
|
|
const segment = chain[i];
|
|
switch (segment.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (i === chain.length - 1 && captureThisArg) {
|
|
if (!isSimpleCopiableExpression(rightExpression)) {
|
|
thisArg = factory2.createTempVariable(hoistVariableDeclaration);
|
|
rightExpression = factory2.createAssignment(thisArg, rightExpression);
|
|
} else {
|
|
thisArg = rightExpression;
|
|
}
|
|
}
|
|
rightExpression = segment.kind === 208 /* PropertyAccessExpression */ ? factory2.createPropertyAccessExpression(rightExpression, visitNode(segment.name, visitor, isIdentifier)) : factory2.createElementAccessExpression(rightExpression, visitNode(segment.argumentExpression, visitor, isExpression));
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
if (i === 0 && leftThisArg) {
|
|
if (!isGeneratedIdentifier(leftThisArg)) {
|
|
leftThisArg = factory2.cloneNode(leftThisArg);
|
|
addEmitFlags(leftThisArg, 3072 /* NoComments */);
|
|
}
|
|
rightExpression = factory2.createFunctionCallCall(
|
|
rightExpression,
|
|
leftThisArg.kind === 106 /* SuperKeyword */ ? factory2.createThis() : leftThisArg,
|
|
visitNodes2(segment.arguments, visitor, isExpression)
|
|
);
|
|
} else {
|
|
rightExpression = factory2.createCallExpression(
|
|
rightExpression,
|
|
void 0,
|
|
visitNodes2(segment.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
setOriginalNode(rightExpression, segment);
|
|
}
|
|
const target = isDelete ? factory2.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), void 0, factory2.createTrue(), void 0, factory2.createDeleteExpression(rightExpression)) : factory2.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), void 0, factory2.createVoidZero(), void 0, rightExpression);
|
|
setTextRange(target, node);
|
|
return thisArg ? factory2.createSyntheticReferenceExpression(target, thisArg) : target;
|
|
}
|
|
function createNotNullCondition(left, right, invert) {
|
|
return factory2.createBinaryExpression(
|
|
factory2.createBinaryExpression(
|
|
left,
|
|
factory2.createToken(invert ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */),
|
|
factory2.createNull()
|
|
),
|
|
factory2.createToken(invert ? 56 /* BarBarToken */ : 55 /* AmpersandAmpersandToken */),
|
|
factory2.createBinaryExpression(
|
|
right,
|
|
factory2.createToken(invert ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */),
|
|
factory2.createVoidZero()
|
|
)
|
|
);
|
|
}
|
|
function transformNullishCoalescingExpression(node) {
|
|
let left = visitNode(node.left, visitor, isExpression);
|
|
let right = left;
|
|
if (!isSimpleCopiableExpression(left)) {
|
|
right = factory2.createTempVariable(hoistVariableDeclaration);
|
|
left = factory2.createAssignment(right, left);
|
|
}
|
|
return setTextRange(factory2.createConditionalExpression(
|
|
createNotNullCondition(left, right),
|
|
void 0,
|
|
right,
|
|
void 0,
|
|
visitNode(node.right, visitor, isExpression)
|
|
), node);
|
|
}
|
|
function visitDeleteExpression(node) {
|
|
return isOptionalChain(skipParentheses(node.expression)) ? setOriginalNode(visitNonOptionalExpression(node.expression, false, true), node) : factory2.updateDeleteExpression(node, visitNode(node.expression, visitor, isExpression));
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2021.ts
|
|
function transformES2021(context) {
|
|
const {
|
|
hoistVariableDeclaration,
|
|
factory: factory2
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 16 /* ContainsES2021 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
const binaryExpression = node;
|
|
if (isLogicalOrCoalescingAssignmentExpression(binaryExpression)) {
|
|
return transformLogicalAssignment(binaryExpression);
|
|
}
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformLogicalAssignment(binaryExpression) {
|
|
const operator = binaryExpression.operatorToken;
|
|
const nonAssignmentOperator = getNonAssignmentOperatorForCompoundAssignment(operator.kind);
|
|
let left = skipParentheses(visitNode(binaryExpression.left, visitor, isLeftHandSideExpression));
|
|
let assignmentTarget = left;
|
|
const right = skipParentheses(visitNode(binaryExpression.right, visitor, isExpression));
|
|
if (isAccessExpression(left)) {
|
|
const propertyAccessTargetSimpleCopiable = isSimpleCopiableExpression(left.expression);
|
|
const propertyAccessTarget = propertyAccessTargetSimpleCopiable ? left.expression : factory2.createTempVariable(hoistVariableDeclaration);
|
|
const propertyAccessTargetAssignment = propertyAccessTargetSimpleCopiable ? left.expression : factory2.createAssignment(
|
|
propertyAccessTarget,
|
|
left.expression
|
|
);
|
|
if (isPropertyAccessExpression(left)) {
|
|
assignmentTarget = factory2.createPropertyAccessExpression(
|
|
propertyAccessTarget,
|
|
left.name
|
|
);
|
|
left = factory2.createPropertyAccessExpression(
|
|
propertyAccessTargetAssignment,
|
|
left.name
|
|
);
|
|
} else {
|
|
const elementAccessArgumentSimpleCopiable = isSimpleCopiableExpression(left.argumentExpression);
|
|
const elementAccessArgument = elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory2.createTempVariable(hoistVariableDeclaration);
|
|
assignmentTarget = factory2.createElementAccessExpression(
|
|
propertyAccessTarget,
|
|
elementAccessArgument
|
|
);
|
|
left = factory2.createElementAccessExpression(
|
|
propertyAccessTargetAssignment,
|
|
elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory2.createAssignment(
|
|
elementAccessArgument,
|
|
left.argumentExpression
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return factory2.createBinaryExpression(
|
|
left,
|
|
nonAssignmentOperator,
|
|
factory2.createParenthesizedExpression(
|
|
factory2.createAssignment(
|
|
assignmentTarget,
|
|
right
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/esnext.ts
|
|
function transformESNext(context) {
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 4 /* ContainsESNext */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/jsx.ts
|
|
function transformJsx(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
let currentSourceFile;
|
|
let currentFileState;
|
|
return chainBundle(context, transformSourceFile);
|
|
function getCurrentFileNameExpression() {
|
|
if (currentFileState.filenameDeclaration) {
|
|
return currentFileState.filenameDeclaration.name;
|
|
}
|
|
const declaration = factory2.createVariableDeclaration(factory2.createUniqueName("_jsxFileName", 16 /* Optimistic */ | 32 /* FileLevel */), void 0, void 0, factory2.createStringLiteral(currentSourceFile.fileName));
|
|
currentFileState.filenameDeclaration = declaration;
|
|
return currentFileState.filenameDeclaration.name;
|
|
}
|
|
function getJsxFactoryCalleePrimitive(isStaticChildren) {
|
|
return compilerOptions.jsx === 5 /* ReactJSXDev */ ? "jsxDEV" : isStaticChildren ? "jsxs" : "jsx";
|
|
}
|
|
function getJsxFactoryCallee(isStaticChildren) {
|
|
const type = getJsxFactoryCalleePrimitive(isStaticChildren);
|
|
return getImplicitImportForName(type);
|
|
}
|
|
function getImplicitJsxFragmentReference() {
|
|
return getImplicitImportForName("Fragment");
|
|
}
|
|
function getImplicitImportForName(name) {
|
|
var _a2, _b;
|
|
const importSource = name === "createElement" ? currentFileState.importSpecifier : getJSXRuntimeImport(currentFileState.importSpecifier, compilerOptions);
|
|
const existing = (_b = (_a2 = currentFileState.utilizedImplicitRuntimeImports) == null ? void 0 : _a2.get(importSource)) == null ? void 0 : _b.get(name);
|
|
if (existing) {
|
|
return existing.name;
|
|
}
|
|
if (!currentFileState.utilizedImplicitRuntimeImports) {
|
|
currentFileState.utilizedImplicitRuntimeImports = /* @__PURE__ */ new Map();
|
|
}
|
|
let specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource);
|
|
if (!specifierSourceImports) {
|
|
specifierSourceImports = /* @__PURE__ */ new Map();
|
|
currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
|
|
}
|
|
const generatedName = factory2.createUniqueName(`_${name}`, 16 /* Optimistic */ | 32 /* FileLevel */ | 64 /* AllowNameSubstitution */);
|
|
const specifier = factory2.createImportSpecifier(false, factory2.createIdentifier(name), generatedName);
|
|
generatedName.generatedImportReference = specifier;
|
|
specifierSourceImports.set(name, specifier);
|
|
return generatedName;
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentFileState = {};
|
|
currentFileState.importSpecifier = getJSXImplicitImportBase(compilerOptions, node);
|
|
let visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
let statements = visited.statements;
|
|
if (currentFileState.filenameDeclaration) {
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([currentFileState.filenameDeclaration], 2 /* Const */)));
|
|
}
|
|
if (currentFileState.utilizedImplicitRuntimeImports) {
|
|
for (const [importSource, importSpecifiersMap] of arrayFrom(currentFileState.utilizedImplicitRuntimeImports.entries())) {
|
|
if (isExternalModule(node)) {
|
|
const importStatement = factory2.createImportDeclaration(void 0, factory2.createImportClause(false, void 0, factory2.createNamedImports(arrayFrom(importSpecifiersMap.values()))), factory2.createStringLiteral(importSource), void 0);
|
|
setParentRecursive(importStatement, false);
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), importStatement);
|
|
} else if (isExternalOrCommonJsModule(node)) {
|
|
const requireStatement = factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createObjectBindingPattern(map(arrayFrom(importSpecifiersMap.values()), (s) => factory2.createBindingElement(void 0, s.propertyName, s.name))),
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(factory2.createIdentifier("require"), void 0, [factory2.createStringLiteral(importSource)])
|
|
)
|
|
], 2 /* Const */));
|
|
setParentRecursive(requireStatement, false);
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), requireStatement);
|
|
} else {
|
|
}
|
|
}
|
|
}
|
|
if (statements !== visited.statements) {
|
|
visited = factory2.updateSourceFile(visited, statements);
|
|
}
|
|
currentFileState = void 0;
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
if (node.transformFlags & 2 /* ContainsJsx */) {
|
|
return visitorWorker(node);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitorWorker(node) {
|
|
switch (node.kind) {
|
|
case 281 /* JsxElement */:
|
|
return visitJsxElement(node, false);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node, false);
|
|
case 285 /* JsxFragment */:
|
|
return visitJsxFragment(node, false);
|
|
case 291 /* JsxExpression */:
|
|
return visitJsxExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformJsxChildToExpression(node) {
|
|
switch (node.kind) {
|
|
case 11 /* JsxText */:
|
|
return visitJsxText(node);
|
|
case 291 /* JsxExpression */:
|
|
return visitJsxExpression(node);
|
|
case 281 /* JsxElement */:
|
|
return visitJsxElement(node, true);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node, true);
|
|
case 285 /* JsxFragment */:
|
|
return visitJsxFragment(node, true);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function hasKeyAfterPropsSpread(node) {
|
|
let spread = false;
|
|
for (const elem of node.attributes.properties) {
|
|
if (isJsxSpreadAttribute(elem)) {
|
|
spread = true;
|
|
} else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function shouldUseCreateElement(node) {
|
|
return currentFileState.importSpecifier === void 0 || hasKeyAfterPropsSpread(node);
|
|
}
|
|
function visitJsxElement(node, isChild) {
|
|
const tagTransform = shouldUseCreateElement(node.openingElement) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
|
|
return tagTransform(node.openingElement, node.children, isChild, node);
|
|
}
|
|
function visitJsxSelfClosingElement(node, isChild) {
|
|
const tagTransform = shouldUseCreateElement(node) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
|
|
return tagTransform(node, void 0, isChild, node);
|
|
}
|
|
function visitJsxFragment(node, isChild) {
|
|
const tagTransform = currentFileState.importSpecifier === void 0 ? visitJsxOpeningFragmentCreateElement : visitJsxOpeningFragmentJSX;
|
|
return tagTransform(node.openingFragment, node.children, isChild, node);
|
|
}
|
|
function convertJsxChildrenToChildrenPropObject(children) {
|
|
const prop = convertJsxChildrenToChildrenPropAssignment(children);
|
|
return prop && factory2.createObjectLiteralExpression([prop]);
|
|
}
|
|
function convertJsxChildrenToChildrenPropAssignment(children) {
|
|
const nonWhitespaceChildren = getSemanticJsxChildren(children);
|
|
if (length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
|
|
const result2 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
|
|
return result2 && factory2.createPropertyAssignment("children", result2);
|
|
}
|
|
const result = mapDefined(children, transformJsxChildToExpression);
|
|
return length(result) ? factory2.createPropertyAssignment("children", factory2.createArrayLiteralExpression(result)) : void 0;
|
|
}
|
|
function visitJsxOpeningLikeElementJSX(node, children, isChild, location) {
|
|
const tagName = getTagName(node);
|
|
const childrenProp = children && children.length ? convertJsxChildrenToChildrenPropAssignment(children) : void 0;
|
|
const keyAttr = find(node.attributes.properties, (p) => !!p.name && isIdentifier(p.name) && p.name.escapedText === "key");
|
|
const attrs = keyAttr ? filter(node.attributes.properties, (p) => p !== keyAttr) : node.attributes.properties;
|
|
const objectProperties = length(attrs) ? transformJsxAttributesToObjectProps(attrs, childrenProp) : factory2.createObjectLiteralExpression(childrenProp ? [childrenProp] : emptyArray);
|
|
return visitJsxOpeningLikeElementOrFragmentJSX(
|
|
tagName,
|
|
objectProperties,
|
|
keyAttr,
|
|
children || emptyArray,
|
|
isChild,
|
|
location
|
|
);
|
|
}
|
|
function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children, isChild, location) {
|
|
var _a2;
|
|
const nonWhitespaceChildren = getSemanticJsxChildren(children);
|
|
const isStaticChildren = length(nonWhitespaceChildren) > 1 || !!((_a2 = nonWhitespaceChildren[0]) == null ? void 0 : _a2.dotDotDotToken);
|
|
const args = [tagName, objectProperties];
|
|
if (keyAttr) {
|
|
args.push(transformJsxAttributeInitializer(keyAttr.initializer));
|
|
}
|
|
if (compilerOptions.jsx === 5 /* ReactJSXDev */) {
|
|
const originalFile = getOriginalNode(currentSourceFile);
|
|
if (originalFile && isSourceFile(originalFile)) {
|
|
if (keyAttr === void 0) {
|
|
args.push(factory2.createVoidZero());
|
|
}
|
|
args.push(isStaticChildren ? factory2.createTrue() : factory2.createFalse());
|
|
const lineCol = getLineAndCharacterOfPosition(originalFile, location.pos);
|
|
args.push(factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("fileName", getCurrentFileNameExpression()),
|
|
factory2.createPropertyAssignment("lineNumber", factory2.createNumericLiteral(lineCol.line + 1)),
|
|
factory2.createPropertyAssignment("columnNumber", factory2.createNumericLiteral(lineCol.character + 1))
|
|
]));
|
|
args.push(factory2.createThis());
|
|
}
|
|
}
|
|
const element = setTextRange(
|
|
factory2.createCallExpression(getJsxFactoryCallee(isStaticChildren), void 0, args),
|
|
location
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function visitJsxOpeningLikeElementCreateElement(node, children, isChild, location) {
|
|
const tagName = getTagName(node);
|
|
const attrs = node.attributes.properties;
|
|
const objectProperties = length(attrs) ? transformJsxAttributesToObjectProps(attrs) : factory2.createNull();
|
|
const callee = currentFileState.importSpecifier === void 0 ? createJsxFactoryExpression(
|
|
factory2,
|
|
context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),
|
|
compilerOptions.reactNamespace,
|
|
node
|
|
) : getImplicitImportForName("createElement");
|
|
const element = createExpressionForJsxElement(
|
|
factory2,
|
|
callee,
|
|
tagName,
|
|
objectProperties,
|
|
mapDefined(children, transformJsxChildToExpression),
|
|
location
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function visitJsxOpeningFragmentJSX(_node, children, isChild, location) {
|
|
let childrenProps;
|
|
if (children && children.length) {
|
|
const result = convertJsxChildrenToChildrenPropObject(children);
|
|
if (result) {
|
|
childrenProps = result;
|
|
}
|
|
}
|
|
return visitJsxOpeningLikeElementOrFragmentJSX(
|
|
getImplicitJsxFragmentReference(),
|
|
childrenProps || factory2.createObjectLiteralExpression([]),
|
|
void 0,
|
|
children,
|
|
isChild,
|
|
location
|
|
);
|
|
}
|
|
function visitJsxOpeningFragmentCreateElement(node, children, isChild, location) {
|
|
const element = createExpressionForJsxFragment(
|
|
factory2,
|
|
context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),
|
|
context.getEmitResolver().getJsxFragmentFactoryEntity(currentSourceFile),
|
|
compilerOptions.reactNamespace,
|
|
mapDefined(children, transformJsxChildToExpression),
|
|
node,
|
|
location
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function transformJsxSpreadAttributeToSpreadAssignment(node) {
|
|
return factory2.createSpreadAssignment(visitNode(node.expression, visitor, isExpression));
|
|
}
|
|
function transformJsxAttributesToObjectProps(attrs, children) {
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
|
|
}
|
|
function transformJsxAttributesToProps(attrs, children) {
|
|
const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
|
|
if (children) {
|
|
props.push(children);
|
|
}
|
|
return props;
|
|
}
|
|
function transformJsxAttributesToExpression(attrs, children) {
|
|
const expressions = flatten(
|
|
spanMap(
|
|
attrs,
|
|
isJsxSpreadAttribute,
|
|
(attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
|
|
)
|
|
);
|
|
if (isJsxSpreadAttribute(attrs[0])) {
|
|
expressions.unshift(factory2.createObjectLiteralExpression());
|
|
}
|
|
if (children) {
|
|
expressions.push(factory2.createObjectLiteralExpression([children]));
|
|
}
|
|
return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
|
|
}
|
|
function transformJsxSpreadAttributeToExpression(node) {
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
function transformJsxAttributeToObjectLiteralElement(node) {
|
|
const name = getAttributeName(node);
|
|
const expression = transformJsxAttributeInitializer(node.initializer);
|
|
return factory2.createPropertyAssignment(name, expression);
|
|
}
|
|
function transformJsxAttributeInitializer(node) {
|
|
if (node === void 0) {
|
|
return factory2.createTrue();
|
|
}
|
|
if (node.kind === 10 /* StringLiteral */) {
|
|
const singleQuote = node.singleQuote !== void 0 ? node.singleQuote : !isStringDoubleQuoted(node, currentSourceFile);
|
|
const literal = factory2.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
|
|
return setTextRange(literal, node);
|
|
}
|
|
if (node.kind === 291 /* JsxExpression */) {
|
|
if (node.expression === void 0) {
|
|
return factory2.createTrue();
|
|
}
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
if (isJsxElement(node)) {
|
|
return visitJsxElement(node, false);
|
|
}
|
|
if (isJsxSelfClosingElement(node)) {
|
|
return visitJsxSelfClosingElement(node, false);
|
|
}
|
|
if (isJsxFragment(node)) {
|
|
return visitJsxFragment(node, false);
|
|
}
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
function visitJsxText(node) {
|
|
const fixed = fixupWhitespaceAndDecodeEntities(node.text);
|
|
return fixed === void 0 ? void 0 : factory2.createStringLiteral(fixed);
|
|
}
|
|
function fixupWhitespaceAndDecodeEntities(text) {
|
|
let acc;
|
|
let firstNonWhitespace = 0;
|
|
let lastNonWhitespace = -1;
|
|
for (let i = 0; i < text.length; i++) {
|
|
const c = text.charCodeAt(i);
|
|
if (isLineBreak(c)) {
|
|
if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) {
|
|
acc = addLineOfJsxText(acc, text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1));
|
|
}
|
|
firstNonWhitespace = -1;
|
|
} else if (!isWhiteSpaceSingleLine(c)) {
|
|
lastNonWhitespace = i;
|
|
if (firstNonWhitespace === -1) {
|
|
firstNonWhitespace = i;
|
|
}
|
|
}
|
|
}
|
|
return firstNonWhitespace !== -1 ? addLineOfJsxText(acc, text.substr(firstNonWhitespace)) : acc;
|
|
}
|
|
function addLineOfJsxText(acc, trimmedLine) {
|
|
const decoded = decodeEntities(trimmedLine);
|
|
return acc === void 0 ? decoded : acc + " " + decoded;
|
|
}
|
|
function decodeEntities(text) {
|
|
return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
|
|
if (decimal) {
|
|
return utf16EncodeAsString(parseInt(decimal, 10));
|
|
} else if (hex) {
|
|
return utf16EncodeAsString(parseInt(hex, 16));
|
|
} else {
|
|
const ch = entities.get(word);
|
|
return ch ? utf16EncodeAsString(ch) : match;
|
|
}
|
|
});
|
|
}
|
|
function tryDecodeEntities(text) {
|
|
const decoded = decodeEntities(text);
|
|
return decoded === text ? void 0 : decoded;
|
|
}
|
|
function getTagName(node) {
|
|
if (node.kind === 281 /* JsxElement */) {
|
|
return getTagName(node.openingElement);
|
|
} else {
|
|
const name = node.tagName;
|
|
if (isIdentifier(name) && isIntrinsicJsxName(name.escapedText)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return createExpressionFromEntityName(factory2, name);
|
|
}
|
|
}
|
|
}
|
|
function getAttributeName(node) {
|
|
const name = node.name;
|
|
const text = idText(name);
|
|
if (/^[A-Za-z_]\w*$/.test(text)) {
|
|
return name;
|
|
} else {
|
|
return factory2.createStringLiteral(text);
|
|
}
|
|
}
|
|
function visitJsxExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return node.dotDotDotToken ? factory2.createSpreadElement(expression) : expression;
|
|
}
|
|
}
|
|
var entities = new Map(getEntries({
|
|
quot: 34,
|
|
amp: 38,
|
|
apos: 39,
|
|
lt: 60,
|
|
gt: 62,
|
|
nbsp: 160,
|
|
iexcl: 161,
|
|
cent: 162,
|
|
pound: 163,
|
|
curren: 164,
|
|
yen: 165,
|
|
brvbar: 166,
|
|
sect: 167,
|
|
uml: 168,
|
|
copy: 169,
|
|
ordf: 170,
|
|
laquo: 171,
|
|
not: 172,
|
|
shy: 173,
|
|
reg: 174,
|
|
macr: 175,
|
|
deg: 176,
|
|
plusmn: 177,
|
|
sup2: 178,
|
|
sup3: 179,
|
|
acute: 180,
|
|
micro: 181,
|
|
para: 182,
|
|
middot: 183,
|
|
cedil: 184,
|
|
sup1: 185,
|
|
ordm: 186,
|
|
raquo: 187,
|
|
frac14: 188,
|
|
frac12: 189,
|
|
frac34: 190,
|
|
iquest: 191,
|
|
Agrave: 192,
|
|
Aacute: 193,
|
|
Acirc: 194,
|
|
Atilde: 195,
|
|
Auml: 196,
|
|
Aring: 197,
|
|
AElig: 198,
|
|
Ccedil: 199,
|
|
Egrave: 200,
|
|
Eacute: 201,
|
|
Ecirc: 202,
|
|
Euml: 203,
|
|
Igrave: 204,
|
|
Iacute: 205,
|
|
Icirc: 206,
|
|
Iuml: 207,
|
|
ETH: 208,
|
|
Ntilde: 209,
|
|
Ograve: 210,
|
|
Oacute: 211,
|
|
Ocirc: 212,
|
|
Otilde: 213,
|
|
Ouml: 214,
|
|
times: 215,
|
|
Oslash: 216,
|
|
Ugrave: 217,
|
|
Uacute: 218,
|
|
Ucirc: 219,
|
|
Uuml: 220,
|
|
Yacute: 221,
|
|
THORN: 222,
|
|
szlig: 223,
|
|
agrave: 224,
|
|
aacute: 225,
|
|
acirc: 226,
|
|
atilde: 227,
|
|
auml: 228,
|
|
aring: 229,
|
|
aelig: 230,
|
|
ccedil: 231,
|
|
egrave: 232,
|
|
eacute: 233,
|
|
ecirc: 234,
|
|
euml: 235,
|
|
igrave: 236,
|
|
iacute: 237,
|
|
icirc: 238,
|
|
iuml: 239,
|
|
eth: 240,
|
|
ntilde: 241,
|
|
ograve: 242,
|
|
oacute: 243,
|
|
ocirc: 244,
|
|
otilde: 245,
|
|
ouml: 246,
|
|
divide: 247,
|
|
oslash: 248,
|
|
ugrave: 249,
|
|
uacute: 250,
|
|
ucirc: 251,
|
|
uuml: 252,
|
|
yacute: 253,
|
|
thorn: 254,
|
|
yuml: 255,
|
|
OElig: 338,
|
|
oelig: 339,
|
|
Scaron: 352,
|
|
scaron: 353,
|
|
Yuml: 376,
|
|
fnof: 402,
|
|
circ: 710,
|
|
tilde: 732,
|
|
Alpha: 913,
|
|
Beta: 914,
|
|
Gamma: 915,
|
|
Delta: 916,
|
|
Epsilon: 917,
|
|
Zeta: 918,
|
|
Eta: 919,
|
|
Theta: 920,
|
|
Iota: 921,
|
|
Kappa: 922,
|
|
Lambda: 923,
|
|
Mu: 924,
|
|
Nu: 925,
|
|
Xi: 926,
|
|
Omicron: 927,
|
|
Pi: 928,
|
|
Rho: 929,
|
|
Sigma: 931,
|
|
Tau: 932,
|
|
Upsilon: 933,
|
|
Phi: 934,
|
|
Chi: 935,
|
|
Psi: 936,
|
|
Omega: 937,
|
|
alpha: 945,
|
|
beta: 946,
|
|
gamma: 947,
|
|
delta: 948,
|
|
epsilon: 949,
|
|
zeta: 950,
|
|
eta: 951,
|
|
theta: 952,
|
|
iota: 953,
|
|
kappa: 954,
|
|
lambda: 955,
|
|
mu: 956,
|
|
nu: 957,
|
|
xi: 958,
|
|
omicron: 959,
|
|
pi: 960,
|
|
rho: 961,
|
|
sigmaf: 962,
|
|
sigma: 963,
|
|
tau: 964,
|
|
upsilon: 965,
|
|
phi: 966,
|
|
chi: 967,
|
|
psi: 968,
|
|
omega: 969,
|
|
thetasym: 977,
|
|
upsih: 978,
|
|
piv: 982,
|
|
ensp: 8194,
|
|
emsp: 8195,
|
|
thinsp: 8201,
|
|
zwnj: 8204,
|
|
zwj: 8205,
|
|
lrm: 8206,
|
|
rlm: 8207,
|
|
ndash: 8211,
|
|
mdash: 8212,
|
|
lsquo: 8216,
|
|
rsquo: 8217,
|
|
sbquo: 8218,
|
|
ldquo: 8220,
|
|
rdquo: 8221,
|
|
bdquo: 8222,
|
|
dagger: 8224,
|
|
Dagger: 8225,
|
|
bull: 8226,
|
|
hellip: 8230,
|
|
permil: 8240,
|
|
prime: 8242,
|
|
Prime: 8243,
|
|
lsaquo: 8249,
|
|
rsaquo: 8250,
|
|
oline: 8254,
|
|
frasl: 8260,
|
|
euro: 8364,
|
|
image: 8465,
|
|
weierp: 8472,
|
|
real: 8476,
|
|
trade: 8482,
|
|
alefsym: 8501,
|
|
larr: 8592,
|
|
uarr: 8593,
|
|
rarr: 8594,
|
|
darr: 8595,
|
|
harr: 8596,
|
|
crarr: 8629,
|
|
lArr: 8656,
|
|
uArr: 8657,
|
|
rArr: 8658,
|
|
dArr: 8659,
|
|
hArr: 8660,
|
|
forall: 8704,
|
|
part: 8706,
|
|
exist: 8707,
|
|
empty: 8709,
|
|
nabla: 8711,
|
|
isin: 8712,
|
|
notin: 8713,
|
|
ni: 8715,
|
|
prod: 8719,
|
|
sum: 8721,
|
|
minus: 8722,
|
|
lowast: 8727,
|
|
radic: 8730,
|
|
prop: 8733,
|
|
infin: 8734,
|
|
ang: 8736,
|
|
and: 8743,
|
|
or: 8744,
|
|
cap: 8745,
|
|
cup: 8746,
|
|
int: 8747,
|
|
there4: 8756,
|
|
sim: 8764,
|
|
cong: 8773,
|
|
asymp: 8776,
|
|
ne: 8800,
|
|
equiv: 8801,
|
|
le: 8804,
|
|
ge: 8805,
|
|
sub: 8834,
|
|
sup: 8835,
|
|
nsub: 8836,
|
|
sube: 8838,
|
|
supe: 8839,
|
|
oplus: 8853,
|
|
otimes: 8855,
|
|
perp: 8869,
|
|
sdot: 8901,
|
|
lceil: 8968,
|
|
rceil: 8969,
|
|
lfloor: 8970,
|
|
rfloor: 8971,
|
|
lang: 9001,
|
|
rang: 9002,
|
|
loz: 9674,
|
|
spades: 9824,
|
|
clubs: 9827,
|
|
hearts: 9829,
|
|
diams: 9830
|
|
}));
|
|
|
|
// src/compiler/transformers/es2016.ts
|
|
function transformES2016(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 512 /* ContainsES2016 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitBinaryExpression(node) {
|
|
switch (node.operatorToken.kind) {
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
return visitExponentiationAssignmentExpression(node);
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return visitExponentiationExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitExponentiationAssignmentExpression(node) {
|
|
let target;
|
|
let value;
|
|
const left = visitNode(node.left, visitor, isExpression);
|
|
const right = visitNode(node.right, visitor, isExpression);
|
|
if (isElementAccessExpression(left)) {
|
|
const expressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const argumentExpressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
target = setTextRange(
|
|
factory2.createElementAccessExpression(
|
|
setTextRange(factory2.createAssignment(expressionTemp, left.expression), left.expression),
|
|
setTextRange(factory2.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)
|
|
),
|
|
left
|
|
);
|
|
value = setTextRange(
|
|
factory2.createElementAccessExpression(
|
|
expressionTemp,
|
|
argumentExpressionTemp
|
|
),
|
|
left
|
|
);
|
|
} else if (isPropertyAccessExpression(left)) {
|
|
const expressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
target = setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
setTextRange(factory2.createAssignment(expressionTemp, left.expression), left.expression),
|
|
left.name
|
|
),
|
|
left
|
|
);
|
|
value = setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
expressionTemp,
|
|
left.name
|
|
),
|
|
left
|
|
);
|
|
} else {
|
|
target = left;
|
|
value = left;
|
|
}
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
target,
|
|
setTextRange(factory2.createGlobalMethodCall("Math", "pow", [value, right]), node)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitExponentiationExpression(node) {
|
|
const left = visitNode(node.left, visitor, isExpression);
|
|
const right = visitNode(node.right, visitor, isExpression);
|
|
return setTextRange(factory2.createGlobalMethodCall("Math", "pow", [left, right]), node);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2015.ts
|
|
function createSpreadSegment(kind, expression) {
|
|
return { kind, expression };
|
|
}
|
|
function transformES2015(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let currentSourceFile;
|
|
let currentText;
|
|
let hierarchyFacts;
|
|
let taggedTemplateStringDeclarations;
|
|
function recordTaggedTemplateString(temp) {
|
|
taggedTemplateStringDeclarations = append(
|
|
taggedTemplateStringDeclarations,
|
|
factory2.createVariableDeclaration(temp)
|
|
);
|
|
}
|
|
let convertedLoopState;
|
|
let enabledSubstitutions;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentText = node.text;
|
|
const visited = visitSourceFile(node);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
currentText = void 0;
|
|
taggedTemplateStringDeclarations = void 0;
|
|
hierarchyFacts = 0 /* None */;
|
|
return visited;
|
|
}
|
|
function enterSubtree(excludeFacts, includeFacts) {
|
|
const ancestorFacts = hierarchyFacts;
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 32767 /* AncestorFactsMask */;
|
|
return ancestorFacts;
|
|
}
|
|
function exitSubtree(ancestorFacts, excludeFacts, includeFacts) {
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & -32768 /* SubtreeFactsMask */ | ancestorFacts;
|
|
}
|
|
function isReturnVoidStatementInConstructorWithCapturedSuper(node) {
|
|
return (hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */) !== 0 && node.kind === 250 /* ReturnStatement */ && !node.expression;
|
|
}
|
|
function isOrMayContainReturnCompletion(node) {
|
|
return node.transformFlags & 4194304 /* ContainsHoistedDeclarationOrCompletion */ && (isReturnStatement(node) || isIfStatement(node) || isWithStatement(node) || isSwitchStatement(node) || isCaseBlock(node) || isCaseClause(node) || isDefaultClause(node) || isTryStatement(node) || isCatchClause(node) || isLabeledStatement(node) || isIterationStatement(node, false) || isBlock(node));
|
|
}
|
|
function shouldVisitNode(node) {
|
|
return (node.transformFlags & 1024 /* ContainsES2015 */) !== 0 || convertedLoopState !== void 0 || hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */ && isOrMayContainReturnCompletion(node) || isIterationStatement(node, false) && shouldConvertIterationStatement(node) || (getEmitFlags(node) & 67108864 /* TypeScriptClassWrapper */) !== 0;
|
|
}
|
|
function visitor(node) {
|
|
return shouldVisitNode(node) ? visitorWorker(node, false) : node;
|
|
}
|
|
function visitorWithUnusedExpressionResult(node) {
|
|
return shouldVisitNode(node) ? visitorWorker(node, true) : node;
|
|
}
|
|
function classWrapperStatementVisitor(node) {
|
|
if (shouldVisitNode(node)) {
|
|
const original = getOriginalNode(node);
|
|
if (isPropertyDeclaration(original) && hasStaticModifier(original)) {
|
|
const ancestorFacts = enterSubtree(
|
|
32670 /* StaticInitializerExcludes */,
|
|
16449 /* StaticInitializerIncludes */
|
|
);
|
|
const result = visitorWorker(node, false);
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
return result;
|
|
}
|
|
return visitorWorker(node, false);
|
|
}
|
|
return node;
|
|
}
|
|
function callExpressionVisitor(node) {
|
|
if (node.kind === 106 /* SuperKeyword */) {
|
|
return visitSuperKeyword(true);
|
|
}
|
|
return visitor(node);
|
|
}
|
|
function visitorWorker(node, expressionResultIsUnused2) {
|
|
switch (node.kind) {
|
|
case 124 /* StaticKeyword */:
|
|
return void 0;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 216 /* ArrowFunction */:
|
|
return visitArrowFunction(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 79 /* Identifier */:
|
|
return visitIdentifier(node);
|
|
case 258 /* VariableDeclarationList */:
|
|
return visitVariableDeclarationList(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 266 /* CaseBlock */:
|
|
return visitCaseBlock(node);
|
|
case 238 /* Block */:
|
|
return visitBlock(node, false);
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
return visitBreakOrContinueStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return visitDoOrWhileStatement(node, void 0);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, void 0);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node, void 0);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, void 0);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return visitShorthandPropertyAssignment(node);
|
|
case 164 /* ComputedPropertyName */:
|
|
return visitComputedPropertyName(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitArrayLiteralExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, expressionResultIsUnused2);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, expressionResultIsUnused2);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node, expressionResultIsUnused2);
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
return visitTemplateLiteral(node);
|
|
case 10 /* StringLiteral */:
|
|
return visitStringLiteral(node);
|
|
case 8 /* NumericLiteral */:
|
|
return visitNumericLiteral(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 225 /* TemplateExpression */:
|
|
return visitTemplateExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 227 /* SpreadElement */:
|
|
return visitSpreadElement(node);
|
|
case 106 /* SuperKeyword */:
|
|
return visitSuperKeyword(false);
|
|
case 108 /* ThisKeyword */:
|
|
return visitThisKeyword(node);
|
|
case 233 /* MetaProperty */:
|
|
return visitMetaProperty(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return visitAccessorDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
case 219 /* VoidExpression */:
|
|
return visitVoidExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitSourceFile(node) {
|
|
const ancestorFacts = enterSubtree(8064 /* SourceFileExcludes */, 64 /* SourceFileIncludes */);
|
|
const prologue = [];
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const statementOffset = factory2.copyPrologue(node.statements, prologue, false, visitor);
|
|
addRange(statements, visitNodes2(node.statements, visitor, isStatement, statementOffset));
|
|
if (taggedTemplateStringDeclarations) {
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(taggedTemplateStringDeclarations)
|
|
)
|
|
);
|
|
}
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureThisForNodeIfNeeded(prologue, node);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(factory2.createNodeArray(concatenate(prologue, statements)), node.statements)
|
|
);
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
if (convertedLoopState !== void 0) {
|
|
const savedAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
|
|
convertedLoopState.allowedNonLabeledJumps |= 2 /* Break */;
|
|
const result = visitEachChild(node, visitor, context);
|
|
convertedLoopState.allowedNonLabeledJumps = savedAllowedNonLabeledJumps;
|
|
return result;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCaseBlock(node) {
|
|
const ancestorFacts = enterSubtree(7104 /* BlockScopeExcludes */, 0 /* BlockScopeIncludes */);
|
|
const updated = visitEachChild(node, visitor, context);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function returnCapturedThis(node) {
|
|
return setOriginalNode(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)), node);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
if (convertedLoopState) {
|
|
convertedLoopState.nonLocalJumps |= 8 /* Return */;
|
|
if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
|
|
node = returnCapturedThis(node);
|
|
}
|
|
return factory2.createReturnStatement(
|
|
factory2.createObjectLiteralExpression(
|
|
[
|
|
factory2.createPropertyAssignment(
|
|
factory2.createIdentifier("value"),
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
)
|
|
]
|
|
)
|
|
);
|
|
} else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
|
|
return returnCapturedThis(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitThisKeyword(node) {
|
|
if (hierarchyFacts & 2 /* ArrowFunction */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
|
|
hierarchyFacts |= 65536 /* CapturedLexicalThis */;
|
|
}
|
|
if (convertedLoopState) {
|
|
if (hierarchyFacts & 2 /* ArrowFunction */) {
|
|
convertedLoopState.containsLexicalThis = true;
|
|
return node;
|
|
}
|
|
return convertedLoopState.thisName || (convertedLoopState.thisName = factory2.createUniqueName("this"));
|
|
}
|
|
return node;
|
|
}
|
|
function visitVoidExpression(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitIdentifier(node) {
|
|
if (convertedLoopState) {
|
|
if (resolver.isArgumentsLocalBinding(node)) {
|
|
return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory2.createUniqueName("arguments"));
|
|
}
|
|
}
|
|
if (node.hasExtendedUnicodeEscape) {
|
|
return setOriginalNode(setTextRange(
|
|
factory2.createIdentifier(unescapeLeadingUnderscores(node.escapedText)),
|
|
node
|
|
), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitBreakOrContinueStatement(node) {
|
|
if (convertedLoopState) {
|
|
const jump = node.kind === 249 /* BreakStatement */ ? 2 /* Break */ : 4 /* Continue */;
|
|
const canUseBreakOrContinue = node.label && convertedLoopState.labels && convertedLoopState.labels.get(idText(node.label)) || !node.label && convertedLoopState.allowedNonLabeledJumps & jump;
|
|
if (!canUseBreakOrContinue) {
|
|
let labelMarker;
|
|
const label = node.label;
|
|
if (!label) {
|
|
if (node.kind === 249 /* BreakStatement */) {
|
|
convertedLoopState.nonLocalJumps |= 2 /* Break */;
|
|
labelMarker = "break";
|
|
} else {
|
|
convertedLoopState.nonLocalJumps |= 4 /* Continue */;
|
|
labelMarker = "continue";
|
|
}
|
|
} else {
|
|
if (node.kind === 249 /* BreakStatement */) {
|
|
labelMarker = `break-${label.escapedText}`;
|
|
setLabeledJump(convertedLoopState, true, idText(label), labelMarker);
|
|
} else {
|
|
labelMarker = `continue-${label.escapedText}`;
|
|
setLabeledJump(convertedLoopState, false, idText(label), labelMarker);
|
|
}
|
|
}
|
|
let returnExpression = factory2.createStringLiteral(labelMarker);
|
|
if (convertedLoopState.loopOutParameters.length) {
|
|
const outParams = convertedLoopState.loopOutParameters;
|
|
let expr;
|
|
for (let i = 0; i < outParams.length; i++) {
|
|
const copyExpr = copyOutParameter(outParams[i], 1 /* ToOutParameter */);
|
|
if (i === 0) {
|
|
expr = copyExpr;
|
|
} else {
|
|
expr = factory2.createBinaryExpression(expr, 27 /* CommaToken */, copyExpr);
|
|
}
|
|
}
|
|
returnExpression = factory2.createBinaryExpression(expr, 27 /* CommaToken */, returnExpression);
|
|
}
|
|
return factory2.createReturnStatement(returnExpression);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
const variable = factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, true),
|
|
void 0,
|
|
void 0,
|
|
transformClassLikeDeclarationToExpression(node)
|
|
);
|
|
setOriginalNode(variable, node);
|
|
const statements = [];
|
|
const statement = factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([variable]));
|
|
setOriginalNode(statement, node);
|
|
setTextRange(statement, node);
|
|
startOnNewLine(statement);
|
|
statements.push(statement);
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
const exportStatement = hasSyntacticModifier(node, 1024 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
|
|
setOriginalNode(exportStatement, statement);
|
|
statements.push(exportStatement);
|
|
}
|
|
const emitFlags = getEmitFlags(node);
|
|
if ((emitFlags & 8388608 /* HasEndOfDeclarationMarker */) === 0) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(statement, emitFlags | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassExpression(node) {
|
|
return transformClassLikeDeclarationToExpression(node);
|
|
}
|
|
function transformClassLikeDeclarationToExpression(node) {
|
|
if (node.name) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const extendsClauseElement = getClassExtendsHeritageElement(node);
|
|
const classFunction = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
extendsClauseElement ? [factory2.createParameterDeclaration(void 0, void 0, factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */))] : [],
|
|
void 0,
|
|
transformClassBody(node, extendsClauseElement)
|
|
);
|
|
setEmitFlags(classFunction, getEmitFlags(node) & 131072 /* Indented */ | 1048576 /* ReuseTempVariableScope */);
|
|
const inner = factory2.createPartiallyEmittedExpression(classFunction);
|
|
setTextRangeEnd(inner, node.end);
|
|
setEmitFlags(inner, 3072 /* NoComments */);
|
|
const outer = factory2.createPartiallyEmittedExpression(inner);
|
|
setTextRangeEnd(outer, skipTrivia(currentText, node.pos));
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const result = factory2.createParenthesizedExpression(
|
|
factory2.createCallExpression(
|
|
outer,
|
|
void 0,
|
|
extendsClauseElement ? [visitNode(extendsClauseElement.expression, visitor, isExpression)] : []
|
|
)
|
|
);
|
|
addSyntheticLeadingComment(result, 3 /* MultiLineCommentTrivia */, "* @class ");
|
|
return result;
|
|
}
|
|
function transformClassBody(node, extendsClauseElement) {
|
|
const statements = [];
|
|
const name = factory2.getInternalName(node);
|
|
const constructorLikeName = isIdentifierANonContextualKeyword(name) ? factory2.getGeneratedNameForNode(name) : name;
|
|
startLexicalEnvironment();
|
|
addExtendsHelperIfNeeded(statements, node, extendsClauseElement);
|
|
addConstructor(statements, node, constructorLikeName, extendsClauseElement);
|
|
addClassMembers(statements, node);
|
|
const closingBraceLocation = createTokenRange(skipTrivia(currentText, node.members.end), 19 /* CloseBraceToken */);
|
|
const outer = factory2.createPartiallyEmittedExpression(constructorLikeName);
|
|
setTextRangeEnd(outer, closingBraceLocation.end);
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const statement = factory2.createReturnStatement(outer);
|
|
setTextRangePos(statement, closingBraceLocation.pos);
|
|
setEmitFlags(statement, 3072 /* NoComments */ | 768 /* NoTokenSourceMaps */);
|
|
statements.push(statement);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), node.members), true);
|
|
setEmitFlags(block, 3072 /* NoComments */);
|
|
return block;
|
|
}
|
|
function addExtendsHelperIfNeeded(statements, node, extendsClauseElement) {
|
|
if (extendsClauseElement) {
|
|
statements.push(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createExtendsHelper(factory2.getInternalName(node))
|
|
),
|
|
extendsClauseElement
|
|
)
|
|
);
|
|
}
|
|
}
|
|
function addConstructor(statements, node, name, extendsClauseElement) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32662 /* ConstructorExcludes */, 73 /* ConstructorIncludes */);
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
const hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== void 0);
|
|
const constructorFunction = factory2.createFunctionDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
transformConstructorParameters(constructor, hasSynthesizedSuper),
|
|
void 0,
|
|
transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)
|
|
);
|
|
setTextRange(constructorFunction, constructor || node);
|
|
if (extendsClauseElement) {
|
|
setEmitFlags(constructorFunction, 16 /* CapturesThis */);
|
|
}
|
|
statements.push(constructorFunction);
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
}
|
|
function transformConstructorParameters(constructor, hasSynthesizedSuper) {
|
|
return visitParameterList(constructor && !hasSynthesizedSuper ? constructor.parameters : void 0, visitor, context) || [];
|
|
}
|
|
function createDefaultConstructorBody(node, isDerivedClass) {
|
|
const statements = [];
|
|
resumeLexicalEnvironment();
|
|
factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
if (isDerivedClass) {
|
|
statements.push(factory2.createReturnStatement(createDefaultSuperCallOrThis()));
|
|
}
|
|
const statementsArray = factory2.createNodeArray(statements);
|
|
setTextRange(statementsArray, node.members);
|
|
const block = factory2.createBlock(statementsArray, true);
|
|
setTextRange(block, node);
|
|
setEmitFlags(block, 3072 /* NoComments */);
|
|
return block;
|
|
}
|
|
function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) {
|
|
const isDerivedClass = !!extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */;
|
|
if (!constructor)
|
|
return createDefaultConstructorBody(node, isDerivedClass);
|
|
const prologue = [];
|
|
const statements = [];
|
|
resumeLexicalEnvironment();
|
|
const existingPrologue = takeWhile(constructor.body.statements, isPrologueDirective);
|
|
const { superCall, superStatementIndex } = findSuperCallAndStatementIndex(constructor.body.statements, existingPrologue);
|
|
const postSuperStatementsStart = superStatementIndex === -1 ? existingPrologue.length : superStatementIndex + 1;
|
|
let statementOffset = postSuperStatementsStart;
|
|
if (!hasSynthesizedSuper)
|
|
statementOffset = factory2.copyStandardPrologue(constructor.body.statements, prologue, statementOffset, false);
|
|
if (!hasSynthesizedSuper)
|
|
statementOffset = factory2.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor, void 0);
|
|
let superCallExpression;
|
|
if (hasSynthesizedSuper) {
|
|
superCallExpression = createDefaultSuperCallOrThis();
|
|
} else if (superCall) {
|
|
superCallExpression = visitSuperCallInBody(superCall);
|
|
}
|
|
if (superCallExpression) {
|
|
hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
|
|
}
|
|
addDefaultValueAssignmentsIfNeeded2(prologue, constructor);
|
|
addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper);
|
|
addRange(statements, visitNodes2(constructor.body.statements, visitor, isStatement, statementOffset));
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureNewTargetIfNeeded(prologue, constructor, false);
|
|
if (isDerivedClass || superCallExpression) {
|
|
if (superCallExpression && postSuperStatementsStart === constructor.body.statements.length && !(constructor.body.transformFlags & 16384 /* ContainsLexicalThis */)) {
|
|
const superCall2 = cast(cast(superCallExpression, isBinaryExpression).left, isCallExpression);
|
|
const returnStatement = factory2.createReturnStatement(superCallExpression);
|
|
setCommentRange(returnStatement, getCommentRange(superCall2));
|
|
setEmitFlags(superCall2, 3072 /* NoComments */);
|
|
statements.push(returnStatement);
|
|
} else {
|
|
if (superStatementIndex <= existingPrologue.length) {
|
|
insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
|
|
} else {
|
|
insertCaptureThisForNode(prologue, constructor, createActualThis());
|
|
if (superCallExpression) {
|
|
insertSuperThisCaptureThisForNode(statements, superCallExpression);
|
|
}
|
|
}
|
|
if (!isSufficientlyCoveredByReturnStatements(constructor.body)) {
|
|
statements.push(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)));
|
|
}
|
|
}
|
|
} else {
|
|
insertCaptureThisForNodeIfNeeded(prologue, constructor);
|
|
}
|
|
const body = factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(
|
|
[
|
|
...existingPrologue,
|
|
...prologue,
|
|
...superStatementIndex <= existingPrologue.length ? emptyArray : visitNodes2(constructor.body.statements, visitor, isStatement, existingPrologue.length, superStatementIndex - existingPrologue.length),
|
|
...statements
|
|
]
|
|
),
|
|
constructor.body.statements
|
|
),
|
|
true
|
|
);
|
|
setTextRange(body, constructor.body);
|
|
return body;
|
|
}
|
|
function findSuperCallAndStatementIndex(originalBodyStatements, existingPrologue) {
|
|
for (let i = existingPrologue.length; i < originalBodyStatements.length; i += 1) {
|
|
const superCall = getSuperCallFromStatement(originalBodyStatements[i]);
|
|
if (superCall) {
|
|
return {
|
|
superCall,
|
|
superStatementIndex: i
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
superStatementIndex: -1
|
|
};
|
|
}
|
|
function isSufficientlyCoveredByReturnStatements(statement) {
|
|
if (statement.kind === 250 /* ReturnStatement */) {
|
|
return true;
|
|
} else if (statement.kind === 242 /* IfStatement */) {
|
|
const ifStatement = statement;
|
|
if (ifStatement.elseStatement) {
|
|
return isSufficientlyCoveredByReturnStatements(ifStatement.thenStatement) && isSufficientlyCoveredByReturnStatements(ifStatement.elseStatement);
|
|
}
|
|
} else if (statement.kind === 238 /* Block */) {
|
|
const lastStatement = lastOrUndefined(statement.statements);
|
|
if (lastStatement && isSufficientlyCoveredByReturnStatements(lastStatement)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createActualThis() {
|
|
return setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */);
|
|
}
|
|
function createDefaultSuperCallOrThis() {
|
|
return factory2.createLogicalOr(
|
|
factory2.createLogicalAnd(
|
|
factory2.createStrictInequality(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
factory2.createNull()
|
|
),
|
|
factory2.createFunctionApplyCall(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
createActualThis(),
|
|
factory2.createIdentifier("arguments")
|
|
)
|
|
),
|
|
createActualThis()
|
|
);
|
|
}
|
|
function visitParameter(node) {
|
|
if (node.dotDotDotToken) {
|
|
return void 0;
|
|
} else if (isBindingPattern(node.name)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else if (node.initializer) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function hasDefaultValueOrBindingPattern(node) {
|
|
return node.initializer !== void 0 || isBindingPattern(node.name);
|
|
}
|
|
function addDefaultValueAssignmentsIfNeeded2(statements, node) {
|
|
if (!some(node.parameters, hasDefaultValueOrBindingPattern)) {
|
|
return false;
|
|
}
|
|
let added = false;
|
|
for (const parameter of node.parameters) {
|
|
const { name, initializer, dotDotDotToken } = parameter;
|
|
if (dotDotDotToken) {
|
|
continue;
|
|
}
|
|
if (isBindingPattern(name)) {
|
|
added = insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) || added;
|
|
} else if (initializer) {
|
|
insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer);
|
|
added = true;
|
|
}
|
|
}
|
|
return added;
|
|
}
|
|
function insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) {
|
|
if (name.elements.length > 0) {
|
|
insertStatementAfterCustomPrologue(
|
|
statements,
|
|
setEmitFlags(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
)
|
|
)
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
return true;
|
|
} else if (initializer) {
|
|
insertStatementAfterCustomPrologue(
|
|
statements,
|
|
setEmitFlags(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
visitNode(initializer, visitor, isExpression)
|
|
)
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer) {
|
|
initializer = visitNode(initializer, visitor, isExpression);
|
|
const statement = factory2.createIfStatement(
|
|
factory2.createTypeCheck(factory2.cloneNode(name), "undefined"),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
setEmitFlags(setParent(setTextRange(factory2.cloneNode(name), name), name.parent), 96 /* NoSourceMap */),
|
|
setEmitFlags(initializer, 96 /* NoSourceMap */ | getEmitFlags(initializer) | 3072 /* NoComments */)
|
|
),
|
|
parameter
|
|
),
|
|
3072 /* NoComments */
|
|
)
|
|
)
|
|
]),
|
|
parameter
|
|
),
|
|
1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */
|
|
)
|
|
);
|
|
startOnNewLine(statement);
|
|
setTextRange(statement, parameter);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2097152 /* CustomPrologue */ | 3072 /* NoComments */);
|
|
insertStatementAfterCustomPrologue(statements, statement);
|
|
}
|
|
function shouldAddRestParameter(node, inConstructorWithSynthesizedSuper) {
|
|
return !!(node && node.dotDotDotToken && !inConstructorWithSynthesizedSuper);
|
|
}
|
|
function addRestParameterIfNeeded(statements, node, inConstructorWithSynthesizedSuper) {
|
|
const prologueStatements = [];
|
|
const parameter = lastOrUndefined(node.parameters);
|
|
if (!shouldAddRestParameter(parameter, inConstructorWithSynthesizedSuper)) {
|
|
return false;
|
|
}
|
|
const declarationName = parameter.name.kind === 79 /* Identifier */ ? setParent(setTextRange(factory2.cloneNode(parameter.name), parameter.name), parameter.name.parent) : factory2.createTempVariable(void 0);
|
|
setEmitFlags(declarationName, 96 /* NoSourceMap */);
|
|
const expressionName = parameter.name.kind === 79 /* Identifier */ ? factory2.cloneNode(parameter.name) : declarationName;
|
|
const restIndex = node.parameters.length - 1;
|
|
const temp = factory2.createLoopVariable();
|
|
prologueStatements.push(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
declarationName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createArrayLiteralExpression([])
|
|
)
|
|
])
|
|
),
|
|
parameter
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
const forStatement = factory2.createForStatement(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(temp, void 0, void 0, factory2.createNumericLiteral(restIndex))
|
|
]),
|
|
parameter
|
|
),
|
|
setTextRange(
|
|
factory2.createLessThan(
|
|
temp,
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("arguments"), "length")
|
|
),
|
|
parameter
|
|
),
|
|
setTextRange(factory2.createPostfixIncrement(temp), parameter),
|
|
factory2.createBlock([
|
|
startOnNewLine(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
expressionName,
|
|
restIndex === 0 ? temp : factory2.createSubtract(temp, factory2.createNumericLiteral(restIndex))
|
|
),
|
|
factory2.createElementAccessExpression(factory2.createIdentifier("arguments"), temp)
|
|
)
|
|
),
|
|
parameter
|
|
)
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(forStatement, 2097152 /* CustomPrologue */);
|
|
startOnNewLine(forStatement);
|
|
prologueStatements.push(forStatement);
|
|
if (parameter.name.kind !== 79 /* Identifier */) {
|
|
prologueStatements.push(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
flattenDestructuringBinding(parameter, visitor, context, 0 /* All */, expressionName)
|
|
)
|
|
),
|
|
parameter
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
}
|
|
insertStatementsAfterCustomPrologue(statements, prologueStatements);
|
|
return true;
|
|
}
|
|
function insertCaptureThisForNodeIfNeeded(statements, node) {
|
|
if (hierarchyFacts & 65536 /* CapturedLexicalThis */ && node.kind !== 216 /* ArrowFunction */) {
|
|
insertCaptureThisForNode(statements, node, factory2.createThis());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function insertSuperThisCaptureThisForNode(statements, superExpression) {
|
|
enableSubstitutionsForCapturedThis();
|
|
const assignSuperExpression = factory2.createExpressionStatement(
|
|
factory2.createBinaryExpression(
|
|
factory2.createThis(),
|
|
63 /* EqualsToken */,
|
|
superExpression
|
|
)
|
|
);
|
|
insertStatementAfterCustomPrologue(statements, assignSuperExpression);
|
|
setCommentRange(assignSuperExpression, getOriginalNode(superExpression).parent);
|
|
}
|
|
function insertCaptureThisForNode(statements, node, initializer) {
|
|
enableSubstitutionsForCapturedThis();
|
|
const captureThisStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
initializer
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(captureThisStatement, 3072 /* NoComments */ | 2097152 /* CustomPrologue */);
|
|
setSourceMapRange(captureThisStatement, node);
|
|
insertStatementAfterCustomPrologue(statements, captureThisStatement);
|
|
}
|
|
function insertCaptureNewTargetIfNeeded(statements, node, copyOnWrite) {
|
|
if (hierarchyFacts & 32768 /* NewTarget */) {
|
|
let newTarget;
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
return statements;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
newTarget = factory2.createVoidZero();
|
|
break;
|
|
case 173 /* Constructor */:
|
|
newTarget = factory2.createPropertyAccessExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
"constructor"
|
|
);
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
newTarget = factory2.createConditionalExpression(
|
|
factory2.createLogicalAnd(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
factory2.createBinaryExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
102 /* InstanceOfKeyword */,
|
|
factory2.getLocalName(node)
|
|
)
|
|
),
|
|
void 0,
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
"constructor"
|
|
),
|
|
void 0,
|
|
factory2.createVoidZero()
|
|
);
|
|
break;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
const captureNewTargetStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_newTarget", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
newTarget
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(captureNewTargetStatement, 3072 /* NoComments */ | 2097152 /* CustomPrologue */);
|
|
if (copyOnWrite) {
|
|
statements = statements.slice();
|
|
}
|
|
insertStatementAfterCustomPrologue(statements, captureNewTargetStatement);
|
|
}
|
|
return statements;
|
|
}
|
|
function addClassMembers(statements, node) {
|
|
for (const member of node.members) {
|
|
switch (member.kind) {
|
|
case 237 /* SemicolonClassElement */:
|
|
statements.push(transformSemicolonClassElementToStatement(member));
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
statements.push(transformClassMethodDeclarationToStatement(getClassMemberPrefix(node, member), member, node));
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const accessors = getAllAccessorDeclarations(node.members, member);
|
|
if (member === accessors.firstAccessor) {
|
|
statements.push(transformAccessorsToStatement(getClassMemberPrefix(node, member), accessors, node));
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(member, currentSourceFile && currentSourceFile.fileName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function transformSemicolonClassElementToStatement(member) {
|
|
return setTextRange(factory2.createEmptyStatement(), member);
|
|
}
|
|
function transformClassMethodDeclarationToStatement(receiver, member, container) {
|
|
const commentRange = getCommentRange(member);
|
|
const sourceMapRange = getSourceMapRange(member);
|
|
const memberFunction = transformFunctionLikeToExpression(member, member, void 0, container);
|
|
const propertyName = visitNode(member.name, visitor, isPropertyName);
|
|
let e;
|
|
if (!isPrivateIdentifier(propertyName) && getUseDefineForClassFields(context.getCompilerOptions())) {
|
|
const name = isComputedPropertyName(propertyName) ? propertyName.expression : isIdentifier(propertyName) ? factory2.createStringLiteral(unescapeLeadingUnderscores(propertyName.escapedText)) : propertyName;
|
|
e = factory2.createObjectDefinePropertyCall(receiver, name, factory2.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true }));
|
|
} else {
|
|
const memberName = createMemberAccessForPropertyName(factory2, receiver, propertyName, member.name);
|
|
e = factory2.createAssignment(memberName, memberFunction);
|
|
}
|
|
setEmitFlags(memberFunction, 3072 /* NoComments */);
|
|
setSourceMapRange(memberFunction, sourceMapRange);
|
|
const statement = setTextRange(factory2.createExpressionStatement(e), member);
|
|
setOriginalNode(statement, member);
|
|
setCommentRange(statement, commentRange);
|
|
setEmitFlags(statement, 96 /* NoSourceMap */);
|
|
return statement;
|
|
}
|
|
function transformAccessorsToStatement(receiver, accessors, container) {
|
|
const statement = factory2.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, false));
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
setSourceMapRange(statement, getSourceMapRange(accessors.firstAccessor));
|
|
return statement;
|
|
}
|
|
function transformAccessorsToExpression(receiver, { firstAccessor, getAccessor, setAccessor }, container, startsOnNewLine) {
|
|
const target = setParent(setTextRange(factory2.cloneNode(receiver), receiver), receiver.parent);
|
|
setEmitFlags(target, 3072 /* NoComments */ | 64 /* NoTrailingSourceMap */);
|
|
setSourceMapRange(target, firstAccessor.name);
|
|
const visitedAccessorName = visitNode(firstAccessor.name, visitor, isPropertyName);
|
|
if (isPrivateIdentifier(visitedAccessorName)) {
|
|
return Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015.");
|
|
}
|
|
const propertyName = createExpressionForPropertyName(factory2, visitedAccessorName);
|
|
setEmitFlags(propertyName, 3072 /* NoComments */ | 32 /* NoLeadingSourceMap */);
|
|
setSourceMapRange(propertyName, firstAccessor.name);
|
|
const properties = [];
|
|
if (getAccessor) {
|
|
const getterFunction = transformFunctionLikeToExpression(getAccessor, void 0, void 0, container);
|
|
setSourceMapRange(getterFunction, getSourceMapRange(getAccessor));
|
|
setEmitFlags(getterFunction, 1024 /* NoLeadingComments */);
|
|
const getter = factory2.createPropertyAssignment("get", getterFunction);
|
|
setCommentRange(getter, getCommentRange(getAccessor));
|
|
properties.push(getter);
|
|
}
|
|
if (setAccessor) {
|
|
const setterFunction = transformFunctionLikeToExpression(setAccessor, void 0, void 0, container);
|
|
setSourceMapRange(setterFunction, getSourceMapRange(setAccessor));
|
|
setEmitFlags(setterFunction, 1024 /* NoLeadingComments */);
|
|
const setter = factory2.createPropertyAssignment("set", setterFunction);
|
|
setCommentRange(setter, getCommentRange(setAccessor));
|
|
properties.push(setter);
|
|
}
|
|
properties.push(
|
|
factory2.createPropertyAssignment("enumerable", getAccessor || setAccessor ? factory2.createFalse() : factory2.createTrue()),
|
|
factory2.createPropertyAssignment("configurable", factory2.createTrue())
|
|
);
|
|
const call = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "defineProperty"),
|
|
void 0,
|
|
[
|
|
target,
|
|
propertyName,
|
|
factory2.createObjectLiteralExpression(properties, true)
|
|
]
|
|
);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(call);
|
|
}
|
|
return call;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
if (node.transformFlags & 16384 /* ContainsLexicalThis */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
|
|
hierarchyFacts |= 65536 /* CapturedLexicalThis */;
|
|
}
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(15232 /* ArrowFunctionExcludes */, 66 /* ArrowFunctionIncludes */);
|
|
const func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformFunctionBody(node)
|
|
);
|
|
setTextRange(func, node);
|
|
setOriginalNode(func, node);
|
|
setEmitFlags(func, 16 /* CapturesThis */);
|
|
exitSubtree(ancestorFacts, 0 /* ArrowFunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return func;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
const ancestorFacts = getEmitFlags(node) & 524288 /* AsyncFunctionBody */ ? enterSubtree(32662 /* AsyncFunctionBodyExcludes */, 69 /* AsyncFunctionBodyIncludes */) : enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody(node);
|
|
const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return factory2.updateFunctionExpression(
|
|
node,
|
|
void 0,
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody(node);
|
|
const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifier),
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
}
|
|
function transformFunctionLikeToExpression(node, location, name, container) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = container && isClassLike(container) && !isStatic(node) ? enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */ | 8 /* NonStaticClassElement */) : enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody(node);
|
|
if (hierarchyFacts & 32768 /* NewTarget */ && !name && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */)) {
|
|
name = factory2.getGeneratedNameForNode(node);
|
|
}
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
),
|
|
location
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function transformFunctionBody(node) {
|
|
let multiLine = false;
|
|
let singleLine = false;
|
|
let statementsLocation;
|
|
let closeBraceLocation;
|
|
const prologue = [];
|
|
const statements = [];
|
|
const body = node.body;
|
|
let statementOffset;
|
|
resumeLexicalEnvironment();
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyStandardPrologue(body.statements, prologue, 0, false);
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor, isHoistedFunction);
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor, isHoistedVariableStatement);
|
|
}
|
|
multiLine = addDefaultValueAssignmentsIfNeeded2(statements, node) || multiLine;
|
|
multiLine = addRestParameterIfNeeded(statements, node, false) || multiLine;
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor);
|
|
statementsLocation = body.statements;
|
|
addRange(statements, visitNodes2(body.statements, visitor, isStatement, statementOffset));
|
|
if (!multiLine && body.multiLine) {
|
|
multiLine = true;
|
|
}
|
|
} else {
|
|
Debug.assert(node.kind === 216 /* ArrowFunction */);
|
|
statementsLocation = moveRangeEnd(body, -1);
|
|
const equalsGreaterThanToken = node.equalsGreaterThanToken;
|
|
if (!nodeIsSynthesized(equalsGreaterThanToken) && !nodeIsSynthesized(body)) {
|
|
if (rangeEndIsOnSameLineAsRangeStart(equalsGreaterThanToken, body, currentSourceFile)) {
|
|
singleLine = true;
|
|
} else {
|
|
multiLine = true;
|
|
}
|
|
}
|
|
const expression = visitNode(body, visitor, isExpression);
|
|
const returnStatement = factory2.createReturnStatement(expression);
|
|
setTextRange(returnStatement, body);
|
|
moveSyntheticComments(returnStatement, body);
|
|
setEmitFlags(returnStatement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2048 /* NoTrailingComments */);
|
|
statements.push(returnStatement);
|
|
closeBraceLocation = body;
|
|
}
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureNewTargetIfNeeded(prologue, node, false);
|
|
insertCaptureThisForNodeIfNeeded(prologue, node);
|
|
if (some(prologue)) {
|
|
multiLine = true;
|
|
}
|
|
statements.unshift(...prologue);
|
|
if (isBlock(body) && arrayIsEqualTo(statements, body.statements)) {
|
|
return body;
|
|
}
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), statementsLocation), multiLine);
|
|
setTextRange(block, node.body);
|
|
if (!multiLine && singleLine) {
|
|
setEmitFlags(block, 1 /* SingleLine */);
|
|
}
|
|
if (closeBraceLocation) {
|
|
setTokenSourceMapRange(block, 19 /* CloseBraceToken */, closeBraceLocation);
|
|
}
|
|
setOriginalNode(block, node.body);
|
|
return block;
|
|
}
|
|
function visitBlock(node, isFunctionBody) {
|
|
if (isFunctionBody) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
const ancestorFacts = hierarchyFacts & 256 /* IterationStatement */ ? enterSubtree(7104 /* IterationStatementBlockExcludes */, 512 /* IterationStatementBlockIncludes */) : enterSubtree(6976 /* BlockExcludes */, 128 /* BlockIncludes */);
|
|
const updated = visitEachChild(node, visitor, context);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitParenthesizedExpression(node, expressionResultIsUnused2) {
|
|
return visitEachChild(node, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, context);
|
|
}
|
|
function visitBinaryExpression(node, expressionResultIsUnused2) {
|
|
if (isDestructuringAssignment(node)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
!expressionResultIsUnused2
|
|
);
|
|
}
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, visitorWithUnusedExpressionResult, isExpression),
|
|
node.operatorToken,
|
|
visitNode(node.right, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaListExpression(node, expressionResultIsUnused2) {
|
|
if (expressionResultIsUnused2) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
let result;
|
|
for (let i = 0; i < node.elements.length; i++) {
|
|
const element = node.elements[i];
|
|
const visited = visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, isExpression);
|
|
if (result || visited !== element) {
|
|
result || (result = node.elements.slice(0, i));
|
|
result.push(visited);
|
|
}
|
|
}
|
|
const elements = result ? setTextRange(factory2.createNodeArray(result), node.elements) : node.elements;
|
|
return factory2.updateCommaListExpression(node, elements);
|
|
}
|
|
function isVariableStatementOfTypeScriptClassWrapper(node) {
|
|
return node.declarationList.declarations.length === 1 && !!node.declarationList.declarations[0].initializer && !!(getEmitFlags(node.declarationList.declarations[0].initializer) & 67108864 /* TypeScriptClassWrapper */);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 1 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
|
|
let updated;
|
|
if (convertedLoopState && (node.declarationList.flags & 3 /* BlockScoped */) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) {
|
|
let assignments;
|
|
for (const decl of node.declarationList.declarations) {
|
|
hoistVariableDeclarationDeclaredInConvertedLoop(convertedLoopState, decl);
|
|
if (decl.initializer) {
|
|
let assignment;
|
|
if (isBindingPattern(decl.name)) {
|
|
assignment = flattenDestructuringAssignment(
|
|
decl,
|
|
visitor,
|
|
context,
|
|
0 /* All */
|
|
);
|
|
} else {
|
|
assignment = factory2.createBinaryExpression(decl.name, 63 /* EqualsToken */, visitNode(decl.initializer, visitor, isExpression));
|
|
setTextRange(assignment, decl);
|
|
}
|
|
assignments = append(assignments, assignment);
|
|
}
|
|
}
|
|
if (assignments) {
|
|
updated = setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(assignments)), node);
|
|
} else {
|
|
updated = void 0;
|
|
}
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitVariableDeclarationList(node) {
|
|
if (node.flags & 3 /* BlockScoped */ || node.transformFlags & 524288 /* ContainsBindingPattern */) {
|
|
if (node.flags & 3 /* BlockScoped */) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const declarations = flatMap(node.declarations, node.flags & 1 /* Let */ ? visitVariableDeclarationInLetDeclarationList : visitVariableDeclaration);
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
setOriginalNode(declarationList, node);
|
|
setTextRange(declarationList, node);
|
|
setCommentRange(declarationList, node);
|
|
if (node.transformFlags & 524288 /* ContainsBindingPattern */ && (isBindingPattern(node.declarations[0].name) || isBindingPattern(last(node.declarations).name))) {
|
|
setSourceMapRange(declarationList, getRangeUnion(declarations));
|
|
}
|
|
return declarationList;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function getRangeUnion(declarations) {
|
|
let pos = -1, end = -1;
|
|
for (const node of declarations) {
|
|
pos = pos === -1 ? node.pos : node.pos === -1 ? pos : Math.min(pos, node.pos);
|
|
end = Math.max(end, node.end);
|
|
}
|
|
return createRange(pos, end);
|
|
}
|
|
function shouldEmitExplicitInitializerForLetDeclaration(node) {
|
|
const flags = resolver.getNodeCheckFlags(node);
|
|
const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
|
|
const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
|
|
const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
|
|
const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
|
|
return emitExplicitInitializer;
|
|
}
|
|
function visitVariableDeclarationInLetDeclarationList(node) {
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
return visitVariableDeclaration(node);
|
|
}
|
|
if (!node.initializer && shouldEmitExplicitInitializerForLetDeclaration(node)) {
|
|
return factory2.updateVariableDeclaration(node, node.name, void 0, void 0, factory2.createVoidZero());
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
const ancestorFacts = enterSubtree(32 /* ExportedVariableStatement */, 0 /* None */);
|
|
let updated;
|
|
if (isBindingPattern(node.name)) {
|
|
updated = flattenDestructuringBinding(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
void 0,
|
|
(ancestorFacts & 32 /* ExportedVariableStatement */) !== 0
|
|
);
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function recordLabel(node) {
|
|
convertedLoopState.labels.set(idText(node.label), true);
|
|
}
|
|
function resetLabel(node) {
|
|
convertedLoopState.labels.set(idText(node.label), false);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (convertedLoopState && !convertedLoopState.labels) {
|
|
convertedLoopState.labels = /* @__PURE__ */ new Map();
|
|
}
|
|
const statement = unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel);
|
|
return isIterationStatement(statement, false) ? visitIterationStatement(statement, node) : factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock), node, convertedLoopState && resetLabel);
|
|
}
|
|
function visitIterationStatement(node, outermostLabeledStatement) {
|
|
switch (node.kind) {
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return visitDoOrWhileStatement(node, outermostLabeledStatement);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, outermostLabeledStatement);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node, outermostLabeledStatement);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, outermostLabeledStatement);
|
|
}
|
|
}
|
|
function visitIterationStatementWithFacts(excludeFacts, includeFacts, node, outermostLabeledStatement, convert) {
|
|
const ancestorFacts = enterSubtree(excludeFacts, includeFacts);
|
|
const updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitDoOrWhileStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
0 /* DoOrWhileStatementExcludes */,
|
|
1280 /* DoOrWhileStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitForStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
5056 /* ForStatementExcludes */,
|
|
3328 /* ForStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitEachChildOfForStatement2(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
visitNode(node.statement, visitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitForInStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
3008 /* ForInOrForOfStatementExcludes */,
|
|
5376 /* ForInOrForOfStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitForOfStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
3008 /* ForInOrForOfStatementExcludes */,
|
|
5376 /* ForInOrForOfStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement,
|
|
compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray
|
|
);
|
|
}
|
|
function convertForOfStatementHead(node, boundValue, convertedLoopBodyStatements) {
|
|
const statements = [];
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
if (node.initializer.flags & 3 /* BlockScoped */) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const firstOriginalDeclaration = firstOrUndefined(initializer.declarations);
|
|
if (firstOriginalDeclaration && isBindingPattern(firstOriginalDeclaration.name)) {
|
|
const declarations = flattenDestructuringBinding(
|
|
firstOriginalDeclaration,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
boundValue
|
|
);
|
|
const declarationList = setTextRange(factory2.createVariableDeclarationList(declarations), node.initializer);
|
|
setOriginalNode(declarationList, node.initializer);
|
|
setSourceMapRange(declarationList, createRange(declarations[0].pos, last(declarations).end));
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
declarationList
|
|
)
|
|
);
|
|
} else {
|
|
statements.push(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
firstOriginalDeclaration ? firstOriginalDeclaration.name : factory2.createTempVariable(void 0),
|
|
void 0,
|
|
void 0,
|
|
boundValue
|
|
)
|
|
]),
|
|
moveRangePos(initializer, -1)
|
|
),
|
|
initializer
|
|
)
|
|
),
|
|
moveRangeEnd(initializer, -1)
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
const assignment = factory2.createAssignment(initializer, boundValue);
|
|
if (isDestructuringAssignment(assignment)) {
|
|
statements.push(factory2.createExpressionStatement(visitBinaryExpression(assignment, true)));
|
|
} else {
|
|
setTextRangeEnd(assignment, initializer.end);
|
|
statements.push(setTextRange(factory2.createExpressionStatement(visitNode(assignment, visitor, isExpression)), moveRangeEnd(initializer, -1)));
|
|
}
|
|
}
|
|
if (convertedLoopBodyStatements) {
|
|
return createSyntheticBlockForConvertedStatements(addRange(statements, convertedLoopBodyStatements));
|
|
} else {
|
|
const statement = visitNode(node.statement, visitor, isStatement, factory2.liftToBlock);
|
|
if (isBlock(statement)) {
|
|
return factory2.updateBlock(statement, setTextRange(factory2.createNodeArray(concatenate(statements, statement.statements)), statement.statements));
|
|
} else {
|
|
statements.push(statement);
|
|
return createSyntheticBlockForConvertedStatements(statements);
|
|
}
|
|
}
|
|
}
|
|
function createSyntheticBlockForConvertedStatements(statements) {
|
|
return setEmitFlags(
|
|
factory2.createBlock(
|
|
factory2.createNodeArray(statements),
|
|
true
|
|
),
|
|
96 /* NoSourceMap */ | 768 /* NoTokenSourceMaps */
|
|
);
|
|
}
|
|
function convertForOfStatementForArray(node, outermostLabeledStatement, convertedLoopBodyStatements) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const counter = factory2.createLoopVariable();
|
|
const rhsReference = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
setEmitFlags(expression, 96 /* NoSourceMap */ | getEmitFlags(expression));
|
|
const forStatement = setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
setTextRange(factory2.createVariableDeclaration(counter, void 0, void 0, factory2.createNumericLiteral(0)), moveRangePos(node.expression, -1)),
|
|
setTextRange(factory2.createVariableDeclaration(rhsReference, void 0, void 0, expression), node.expression)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
setTextRange(
|
|
factory2.createLessThan(
|
|
counter,
|
|
factory2.createPropertyAccessExpression(rhsReference, "length")
|
|
),
|
|
node.expression
|
|
),
|
|
setTextRange(factory2.createPostfixIncrement(counter), node.expression),
|
|
convertForOfStatementHead(
|
|
node,
|
|
factory2.createElementAccessExpression(rhsReference, counter),
|
|
convertedLoopBodyStatements
|
|
)
|
|
),
|
|
node
|
|
);
|
|
setEmitFlags(forStatement, 512 /* NoTokenTrailingSourceMaps */);
|
|
setTextRange(forStatement, node);
|
|
return factory2.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const iterator = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
const result = isIdentifier(expression) ? factory2.getGeneratedNameForNode(iterator) : factory2.createTempVariable(void 0);
|
|
const errorRecord = factory2.createUniqueName("e");
|
|
const catchVariable = factory2.getGeneratedNameForNode(errorRecord);
|
|
const returnMethod = factory2.createTempVariable(void 0);
|
|
const values = setTextRange(emitHelpers().createValuesHelper(expression), node.expression);
|
|
const next = factory2.createCallExpression(factory2.createPropertyAccessExpression(iterator, "next"), void 0, []);
|
|
hoistVariableDeclaration(errorRecord);
|
|
hoistVariableDeclaration(returnMethod);
|
|
const initializer = ancestorFacts & 1024 /* IterationContainer */ ? factory2.inlineExpressions([factory2.createAssignment(errorRecord, factory2.createVoidZero()), values]) : values;
|
|
const forStatement = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
setTextRange(factory2.createVariableDeclaration(iterator, void 0, void 0, initializer), node.expression),
|
|
factory2.createVariableDeclaration(result, void 0, void 0, next)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
factory2.createLogicalNot(factory2.createPropertyAccessExpression(result, "done")),
|
|
factory2.createAssignment(result, next),
|
|
convertForOfStatementHead(
|
|
node,
|
|
factory2.createPropertyAccessExpression(result, "value"),
|
|
convertedLoopBodyStatements
|
|
)
|
|
),
|
|
node
|
|
),
|
|
512 /* NoTokenTrailingSourceMaps */
|
|
);
|
|
return factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
factory2.restoreEnclosingLabel(
|
|
forStatement,
|
|
outermostLabeledStatement,
|
|
convertedLoopState && resetLabel
|
|
)
|
|
]),
|
|
factory2.createCatchClause(
|
|
factory2.createVariableDeclaration(catchVariable),
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
errorRecord,
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("error", catchVariable)
|
|
])
|
|
)
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalAnd(
|
|
result,
|
|
factory2.createLogicalNot(
|
|
factory2.createPropertyAccessExpression(result, "done")
|
|
)
|
|
),
|
|
factory2.createAssignment(
|
|
returnMethod,
|
|
factory2.createPropertyAccessExpression(iterator, "return")
|
|
)
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createFunctionCallCall(returnMethod, iterator, [])
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
errorRecord,
|
|
factory2.createThrowStatement(
|
|
factory2.createPropertyAccessExpression(errorRecord, "error")
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
const properties = node.properties;
|
|
let numInitialProperties = -1, hasComputed = false;
|
|
for (let i = 0; i < properties.length; i++) {
|
|
const property = properties[i];
|
|
if (property.transformFlags & 1048576 /* ContainsYield */ && hierarchyFacts & 4 /* AsyncFunctionBody */ || (hasComputed = Debug.checkDefined(property.name).kind === 164 /* ComputedPropertyName */)) {
|
|
numInitialProperties = i;
|
|
break;
|
|
}
|
|
}
|
|
if (numInitialProperties < 0) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const expressions = [];
|
|
const assignment = factory2.createAssignment(
|
|
temp,
|
|
setEmitFlags(
|
|
factory2.createObjectLiteralExpression(
|
|
visitNodes2(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
|
|
node.multiLine
|
|
),
|
|
hasComputed ? 131072 /* Indented */ : 0
|
|
)
|
|
);
|
|
if (node.multiLine) {
|
|
startOnNewLine(assignment);
|
|
}
|
|
expressions.push(assignment);
|
|
addObjectLiteralMembers(expressions, node, temp, numInitialProperties);
|
|
expressions.push(node.multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
|
|
return factory2.inlineExpressions(expressions);
|
|
}
|
|
function shouldConvertPartOfIterationStatement(node) {
|
|
return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
|
|
}
|
|
function shouldConvertInitializerOfForStatement(node) {
|
|
return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
|
|
}
|
|
function shouldConvertConditionOfForStatement(node) {
|
|
return isForStatement(node) && !!node.condition && shouldConvertPartOfIterationStatement(node.condition);
|
|
}
|
|
function shouldConvertIncrementorOfForStatement(node) {
|
|
return isForStatement(node) && !!node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor);
|
|
}
|
|
function shouldConvertIterationStatement(node) {
|
|
return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
|
|
}
|
|
function shouldConvertBodyOfIterationStatement(node) {
|
|
return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
|
|
}
|
|
function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
|
|
if (!state.hoistedLocalVariables) {
|
|
state.hoistedLocalVariables = [];
|
|
}
|
|
visit(node.name);
|
|
function visit(node2) {
|
|
if (node2.kind === 79 /* Identifier */) {
|
|
state.hoistedLocalVariables.push(node2);
|
|
} else {
|
|
for (const element of node2.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
visit(element.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert) {
|
|
if (!shouldConvertIterationStatement(node)) {
|
|
let saveAllowedNonLabeledJumps;
|
|
if (convertedLoopState) {
|
|
saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
|
|
convertedLoopState.allowedNonLabeledJumps = 2 /* Break */ | 4 /* Continue */;
|
|
}
|
|
const result = convert ? convert(node, outermostLabeledStatement, void 0, ancestorFacts) : factory2.restoreEnclosingLabel(
|
|
isForStatement(node) ? visitEachChildOfForStatement2(node) : visitEachChild(node, visitor, context),
|
|
outermostLabeledStatement,
|
|
convertedLoopState && resetLabel
|
|
);
|
|
if (convertedLoopState) {
|
|
convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
|
|
}
|
|
return result;
|
|
}
|
|
const currentState = createConvertedLoopState(node);
|
|
const statements = [];
|
|
const outerConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = currentState;
|
|
const initializerFunction = shouldConvertInitializerOfForStatement(node) ? createFunctionForInitializerOfForStatement(node, currentState) : void 0;
|
|
const bodyFunction = shouldConvertBodyOfIterationStatement(node) ? createFunctionForBodyOfIterationStatement(node, currentState, outerConvertedLoopState) : void 0;
|
|
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));
|
|
}
|
|
let loop;
|
|
if (bodyFunction) {
|
|
if (convert) {
|
|
loop = convert(node, outermostLabeledStatement, bodyFunction.part, ancestorFacts);
|
|
} else {
|
|
const clone2 = convertIterationStatementCore(node, initializerFunction, factory2.createBlock(bodyFunction.part, true));
|
|
loop = factory2.restoreEnclosingLabel(clone2, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
} else {
|
|
const clone2 = convertIterationStatementCore(node, initializerFunction, visitNode(node.statement, visitor, isStatement, factory2.liftToBlock));
|
|
loop = factory2.restoreEnclosingLabel(clone2, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
statements.push(loop);
|
|
return statements;
|
|
}
|
|
function convertIterationStatementCore(node, initializerFunction, convertedLoopBody) {
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return convertForStatement(node, initializerFunction, convertedLoopBody);
|
|
case 246 /* ForInStatement */:
|
|
return convertForInStatement(node, convertedLoopBody);
|
|
case 247 /* ForOfStatement */:
|
|
return convertForOfStatement(node, convertedLoopBody);
|
|
case 243 /* DoStatement */:
|
|
return convertDoStatement(node, convertedLoopBody);
|
|
case 244 /* WhileStatement */:
|
|
return convertWhileStatement(node, convertedLoopBody);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node, "IterationStatement expected");
|
|
}
|
|
}
|
|
function convertForStatement(node, initializerFunction, convertedLoopBody) {
|
|
const shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition);
|
|
const shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor);
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(shouldConvertCondition ? void 0 : node.condition, visitor, isExpression),
|
|
visitNode(shouldConvertIncrementor ? void 0 : node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertForOfStatement(node, convertedLoopBody) {
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertForInStatement(node, convertedLoopBody) {
|
|
return factory2.updateForInStatement(
|
|
node,
|
|
visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertDoStatement(node, convertedLoopBody) {
|
|
return factory2.updateDoStatement(
|
|
node,
|
|
convertedLoopBody,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
);
|
|
}
|
|
function convertWhileStatement(node, convertedLoopBody) {
|
|
return factory2.updateWhileStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function createConvertedLoopState(node) {
|
|
let loopInitializer;
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
const initializer = node.initializer;
|
|
if (initializer && initializer.kind === 258 /* VariableDeclarationList */) {
|
|
loopInitializer = initializer;
|
|
}
|
|
break;
|
|
}
|
|
const loopParameters = [];
|
|
const loopOutParameters = [];
|
|
if (loopInitializer && getCombinedNodeFlags(loopInitializer) & 3 /* BlockScoped */) {
|
|
const hasCapturedBindingsInForHead = shouldConvertInitializerOfForStatement(node) || shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node);
|
|
for (const decl of loopInitializer.declarations) {
|
|
processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
|
|
}
|
|
}
|
|
const currentState = { loopParameters, loopOutParameters };
|
|
if (convertedLoopState) {
|
|
if (convertedLoopState.argumentsName) {
|
|
currentState.argumentsName = convertedLoopState.argumentsName;
|
|
}
|
|
if (convertedLoopState.thisName) {
|
|
currentState.thisName = convertedLoopState.thisName;
|
|
}
|
|
if (convertedLoopState.hoistedLocalVariables) {
|
|
currentState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables;
|
|
}
|
|
}
|
|
return currentState;
|
|
}
|
|
function addExtraDeclarationsForConvertedLoop(statements, state, outerState) {
|
|
let extraVariableDeclarations;
|
|
if (state.argumentsName) {
|
|
if (outerState) {
|
|
outerState.argumentsName = state.argumentsName;
|
|
} else {
|
|
(extraVariableDeclarations || (extraVariableDeclarations = [])).push(
|
|
factory2.createVariableDeclaration(
|
|
state.argumentsName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createIdentifier("arguments")
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (state.thisName) {
|
|
if (outerState) {
|
|
outerState.thisName = state.thisName;
|
|
} else {
|
|
(extraVariableDeclarations || (extraVariableDeclarations = [])).push(
|
|
factory2.createVariableDeclaration(
|
|
state.thisName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createIdentifier("this")
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (state.hoistedLocalVariables) {
|
|
if (outerState) {
|
|
outerState.hoistedLocalVariables = state.hoistedLocalVariables;
|
|
} else {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
for (const identifier of state.hoistedLocalVariables) {
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(identifier));
|
|
}
|
|
}
|
|
}
|
|
if (state.loopOutParameters.length) {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
for (const outParam of state.loopOutParameters) {
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(outParam.outParamName));
|
|
}
|
|
}
|
|
if (state.conditionVariable) {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(state.conditionVariable, void 0, void 0, factory2.createFalse()));
|
|
}
|
|
if (extraVariableDeclarations) {
|
|
statements.push(factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(extraVariableDeclarations)
|
|
));
|
|
}
|
|
}
|
|
function createOutVariable(p) {
|
|
return factory2.createVariableDeclaration(p.originalName, void 0, void 0, p.outParamName);
|
|
}
|
|
function createFunctionForInitializerOfForStatement(node, currentState) {
|
|
const functionName = factory2.createUniqueName("_loop_init");
|
|
const containsYield = (node.initializer.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
let emitFlags = 0 /* None */;
|
|
if (currentState.containsLexicalThis)
|
|
emitFlags |= 16 /* CapturesThis */;
|
|
if (containsYield && hierarchyFacts & 4 /* AsyncFunctionBody */)
|
|
emitFlags |= 524288 /* AsyncFunctionBody */;
|
|
const statements = [];
|
|
statements.push(factory2.createVariableStatement(void 0, node.initializer));
|
|
copyOutParameters(currentState.loopOutParameters, 2 /* Initializer */, 1 /* ToOutParameter */, statements);
|
|
const functionDeclaration = factory2.createVariableStatement(
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
functionName,
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
containsYield ? factory2.createToken(41 /* AsteriskToken */) : void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
visitNode(
|
|
factory2.createBlock(statements, true),
|
|
visitor,
|
|
isBlock
|
|
)
|
|
),
|
|
emitFlags
|
|
)
|
|
)
|
|
]),
|
|
4194304 /* NoHoisting */
|
|
)
|
|
);
|
|
const part = factory2.createVariableDeclarationList(map(currentState.loopOutParameters, createOutVariable));
|
|
return { functionName, containsYield, functionDeclaration, part };
|
|
}
|
|
function createFunctionForBodyOfIterationStatement(node, currentState, outerState) {
|
|
const functionName = factory2.createUniqueName("_loop");
|
|
startLexicalEnvironment();
|
|
const statement = visitNode(node.statement, visitor, isStatement, factory2.liftToBlock);
|
|
const lexicalEnvironment = endLexicalEnvironment();
|
|
const statements = [];
|
|
if (shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node)) {
|
|
currentState.conditionVariable = factory2.createUniqueName("inc");
|
|
if (node.incrementor) {
|
|
statements.push(factory2.createIfStatement(
|
|
currentState.conditionVariable,
|
|
factory2.createExpressionStatement(visitNode(node.incrementor, visitor, isExpression)),
|
|
factory2.createExpressionStatement(factory2.createAssignment(currentState.conditionVariable, factory2.createTrue()))
|
|
));
|
|
} else {
|
|
statements.push(factory2.createIfStatement(
|
|
factory2.createLogicalNot(currentState.conditionVariable),
|
|
factory2.createExpressionStatement(factory2.createAssignment(currentState.conditionVariable, factory2.createTrue()))
|
|
));
|
|
}
|
|
if (shouldConvertConditionOfForStatement(node)) {
|
|
statements.push(factory2.createIfStatement(
|
|
factory2.createPrefixUnaryExpression(53 /* ExclamationToken */, visitNode(node.condition, visitor, isExpression)),
|
|
visitNode(factory2.createBreakStatement(), visitor, isStatement)
|
|
));
|
|
}
|
|
}
|
|
if (isBlock(statement)) {
|
|
addRange(statements, statement.statements);
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
copyOutParameters(currentState.loopOutParameters, 1 /* Body */, 1 /* ToOutParameter */, statements);
|
|
insertStatementsAfterStandardPrologue(statements, lexicalEnvironment);
|
|
const loopBody = factory2.createBlock(statements, true);
|
|
if (isBlock(statement))
|
|
setOriginalNode(loopBody, statement);
|
|
const containsYield = (node.statement.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
let emitFlags = 1048576 /* ReuseTempVariableScope */;
|
|
if (currentState.containsLexicalThis)
|
|
emitFlags |= 16 /* CapturesThis */;
|
|
if (containsYield && (hierarchyFacts & 4 /* AsyncFunctionBody */) !== 0)
|
|
emitFlags |= 524288 /* AsyncFunctionBody */;
|
|
const functionDeclaration = factory2.createVariableStatement(
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
functionName,
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
containsYield ? factory2.createToken(41 /* AsteriskToken */) : void 0,
|
|
void 0,
|
|
void 0,
|
|
currentState.loopParameters,
|
|
void 0,
|
|
loopBody
|
|
),
|
|
emitFlags
|
|
)
|
|
)
|
|
]
|
|
),
|
|
4194304 /* NoHoisting */
|
|
)
|
|
);
|
|
const part = generateCallToConvertedLoop(functionName, currentState, outerState, containsYield);
|
|
return { functionName, containsYield, functionDeclaration, part };
|
|
}
|
|
function copyOutParameter(outParam, copyDirection) {
|
|
const source = copyDirection === 0 /* ToOriginal */ ? outParam.outParamName : outParam.originalName;
|
|
const target = copyDirection === 0 /* ToOriginal */ ? outParam.originalName : outParam.outParamName;
|
|
return factory2.createBinaryExpression(target, 63 /* EqualsToken */, source);
|
|
}
|
|
function copyOutParameters(outParams, partFlags, copyDirection, statements) {
|
|
for (const outParam of outParams) {
|
|
if (outParam.flags & partFlags) {
|
|
statements.push(factory2.createExpressionStatement(copyOutParameter(outParam, copyDirection)));
|
|
}
|
|
}
|
|
}
|
|
function generateCallToConvertedLoopInitializer(initFunctionExpressionName, containsYield) {
|
|
const call = factory2.createCallExpression(initFunctionExpressionName, void 0, []);
|
|
const callResult = containsYield ? factory2.createYieldExpression(
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
setEmitFlags(call, 16777216 /* Iterator */)
|
|
) : call;
|
|
return factory2.createExpressionStatement(callResult);
|
|
}
|
|
function generateCallToConvertedLoop(loopFunctionExpressionName, state, outerState, containsYield) {
|
|
const statements = [];
|
|
const isSimpleLoop = !(state.nonLocalJumps & ~4 /* Continue */) && !state.labeledNonLocalBreaks && !state.labeledNonLocalContinues;
|
|
const call = factory2.createCallExpression(loopFunctionExpressionName, void 0, map(state.loopParameters, (p) => p.name));
|
|
const callResult = containsYield ? factory2.createYieldExpression(
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
setEmitFlags(call, 16777216 /* Iterator */)
|
|
) : call;
|
|
if (isSimpleLoop) {
|
|
statements.push(factory2.createExpressionStatement(callResult));
|
|
copyOutParameters(state.loopOutParameters, 1 /* Body */, 0 /* ToOriginal */, statements);
|
|
} else {
|
|
const loopResultName = factory2.createUniqueName("state");
|
|
const stateVariable = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[factory2.createVariableDeclaration(loopResultName, void 0, void 0, callResult)]
|
|
)
|
|
);
|
|
statements.push(stateVariable);
|
|
copyOutParameters(state.loopOutParameters, 1 /* Body */, 0 /* ToOriginal */, statements);
|
|
if (state.nonLocalJumps & 8 /* Return */) {
|
|
let returnStatement;
|
|
if (outerState) {
|
|
outerState.nonLocalJumps |= 8 /* Return */;
|
|
returnStatement = factory2.createReturnStatement(loopResultName);
|
|
} else {
|
|
returnStatement = factory2.createReturnStatement(factory2.createPropertyAccessExpression(loopResultName, "value"));
|
|
}
|
|
statements.push(
|
|
factory2.createIfStatement(
|
|
factory2.createTypeCheck(loopResultName, "object"),
|
|
returnStatement
|
|
)
|
|
);
|
|
}
|
|
if (state.nonLocalJumps & 2 /* Break */) {
|
|
statements.push(
|
|
factory2.createIfStatement(
|
|
factory2.createStrictEquality(
|
|
loopResultName,
|
|
factory2.createStringLiteral("break")
|
|
),
|
|
factory2.createBreakStatement()
|
|
)
|
|
);
|
|
}
|
|
if (state.labeledNonLocalBreaks || state.labeledNonLocalContinues) {
|
|
const caseClauses = [];
|
|
processLabeledJumps(state.labeledNonLocalBreaks, true, loopResultName, outerState, caseClauses);
|
|
processLabeledJumps(state.labeledNonLocalContinues, false, loopResultName, outerState, caseClauses);
|
|
statements.push(
|
|
factory2.createSwitchStatement(
|
|
loopResultName,
|
|
factory2.createCaseBlock(caseClauses)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function setLabeledJump(state, isBreak, labelText, labelMarker) {
|
|
if (isBreak) {
|
|
if (!state.labeledNonLocalBreaks) {
|
|
state.labeledNonLocalBreaks = /* @__PURE__ */ new Map();
|
|
}
|
|
state.labeledNonLocalBreaks.set(labelText, labelMarker);
|
|
} else {
|
|
if (!state.labeledNonLocalContinues) {
|
|
state.labeledNonLocalContinues = /* @__PURE__ */ new Map();
|
|
}
|
|
state.labeledNonLocalContinues.set(labelText, labelMarker);
|
|
}
|
|
}
|
|
function processLabeledJumps(table, isBreak, loopResultName, outerLoop, caseClauses) {
|
|
if (!table) {
|
|
return;
|
|
}
|
|
table.forEach((labelMarker, labelText) => {
|
|
const statements = [];
|
|
if (!outerLoop || outerLoop.labels && outerLoop.labels.get(labelText)) {
|
|
const label = factory2.createIdentifier(labelText);
|
|
statements.push(isBreak ? factory2.createBreakStatement(label) : factory2.createContinueStatement(label));
|
|
} else {
|
|
setLabeledJump(outerLoop, isBreak, labelText, labelMarker);
|
|
statements.push(factory2.createReturnStatement(loopResultName));
|
|
}
|
|
caseClauses.push(factory2.createCaseClause(factory2.createStringLiteral(labelMarker), statements));
|
|
});
|
|
}
|
|
function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead) {
|
|
const name = decl.name;
|
|
if (isBindingPattern(name)) {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
|
|
}
|
|
}
|
|
} else {
|
|
loopParameters.push(factory2.createParameterDeclaration(void 0, void 0, name));
|
|
const checkFlags = resolver.getNodeCheckFlags(decl);
|
|
if (checkFlags & 262144 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
|
|
const outParamName = factory2.createUniqueName("out_" + idText(name));
|
|
let flags = 0 /* None */;
|
|
if (checkFlags & 262144 /* NeedsLoopOutParameter */) {
|
|
flags |= 1 /* Body */;
|
|
}
|
|
if (isForStatement(container)) {
|
|
if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
|
|
flags |= 2 /* Initializer */;
|
|
}
|
|
if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) || container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) {
|
|
flags |= 1 /* Body */;
|
|
}
|
|
}
|
|
loopOutParameters.push({ flags, originalName: name, outParamName });
|
|
}
|
|
}
|
|
}
|
|
function addObjectLiteralMembers(expressions, node, receiver, start) {
|
|
const properties = node.properties;
|
|
const numProperties = properties.length;
|
|
for (let i = start; i < numProperties; i++) {
|
|
const property = properties[i];
|
|
switch (property.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const accessors = getAllAccessorDeclarations(node.properties, property);
|
|
if (property === accessors.firstAccessor) {
|
|
expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine));
|
|
}
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine));
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine));
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine));
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(node);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(property.name, visitor, isPropertyName)
|
|
),
|
|
visitNode(property.initializer, visitor, isExpression)
|
|
);
|
|
setTextRange(expression, property);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(property.name, visitor, isPropertyName)
|
|
),
|
|
factory2.cloneNode(property.name)
|
|
);
|
|
setTextRange(expression, property);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function transformObjectLiteralMethodDeclarationToExpression(method, receiver, container, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(method.name, visitor, isPropertyName)
|
|
),
|
|
transformFunctionLikeToExpression(method, method, void 0, container)
|
|
);
|
|
setTextRange(expression, method);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function visitCatchClause(node) {
|
|
const ancestorFacts = enterSubtree(7104 /* BlockScopeExcludes */, 0 /* BlockScopeIncludes */);
|
|
let updated;
|
|
Debug.assert(!!node.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015.");
|
|
if (isBindingPattern(node.variableDeclaration.name)) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
const newVariableDeclaration = factory2.createVariableDeclaration(temp);
|
|
setTextRange(newVariableDeclaration, node.variableDeclaration);
|
|
const vars = flattenDestructuringBinding(
|
|
node.variableDeclaration,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
temp
|
|
);
|
|
const list = factory2.createVariableDeclarationList(vars);
|
|
setTextRange(list, node.variableDeclaration);
|
|
const destructure = factory2.createVariableStatement(void 0, list);
|
|
updated = factory2.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure));
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function addStatementToStartOfBlock(block, statement) {
|
|
const transformedStatements = visitNodes2(block.statements, visitor, isStatement);
|
|
return factory2.updateBlock(block, [statement, ...transformedStatements]);
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
Debug.assert(!isComputedPropertyName(node.name));
|
|
const functionExpression = transformFunctionLikeToExpression(node, moveRangePos(node, -1), void 0, void 0);
|
|
setEmitFlags(functionExpression, 1024 /* NoLeadingComments */ | getEmitFlags(functionExpression));
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
node.name,
|
|
functionExpression
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitAccessorDeclaration(node) {
|
|
Debug.assert(!isComputedPropertyName(node.name));
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
let updated;
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody(node);
|
|
if (node.kind === 174 /* GetAccessor */) {
|
|
updated = factory2.updateGetAccessorDeclaration(node, node.modifiers, node.name, parameters, node.type, body);
|
|
} else {
|
|
updated = factory2.updateSetAccessorDeclaration(node, node.modifiers, node.name, parameters, body);
|
|
}
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return updated;
|
|
}
|
|
function visitShorthandPropertyAssignment(node) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
node.name,
|
|
visitIdentifier(factory2.cloneNode(node.name))
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitComputedPropertyName(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitArrayLiteralExpression(node) {
|
|
if (some(node.elements, isSpreadElement)) {
|
|
return transformAndSpreadElements(node.elements, false, !!node.multiLine, !!node.elements.hasTrailingComma);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (getEmitFlags(node) & 67108864 /* TypeScriptClassWrapper */) {
|
|
return visitTypeScriptClassWrapper(node);
|
|
}
|
|
const expression = skipOuterExpressions(node.expression);
|
|
if (expression.kind === 106 /* SuperKeyword */ || isSuperProperty(expression) || some(node.arguments, isSpreadElement)) {
|
|
return visitCallExpressionWithPotentialCapturedThisAssignment(node, true);
|
|
}
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
visitNode(node.expression, callExpressionVisitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitTypeScriptClassWrapper(node) {
|
|
const body = cast(cast(skipOuterExpressions(node.expression), isArrowFunction).body, isBlock);
|
|
const isVariableStatementWithInitializer = (stmt) => isVariableStatement(stmt) && !!first(stmt.declarationList.declarations).initializer;
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const bodyStatements = visitNodes2(body.statements, classWrapperStatementVisitor, isStatement);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
const classStatements = filter(bodyStatements, isVariableStatementWithInitializer);
|
|
const remainingStatements = filter(bodyStatements, (stmt) => !isVariableStatementWithInitializer(stmt));
|
|
const varStatement = cast(first(classStatements), isVariableStatement);
|
|
const variable = varStatement.declarationList.declarations[0];
|
|
const initializer = skipOuterExpressions(variable.initializer);
|
|
let aliasAssignment = tryCast(initializer, isAssignmentExpression);
|
|
if (!aliasAssignment && isBinaryExpression(initializer) && initializer.operatorToken.kind === 27 /* CommaToken */) {
|
|
aliasAssignment = tryCast(initializer.left, isAssignmentExpression);
|
|
}
|
|
const call = cast(aliasAssignment ? skipOuterExpressions(aliasAssignment.right) : initializer, isCallExpression);
|
|
const func = cast(skipOuterExpressions(call.expression), isFunctionExpression);
|
|
const funcStatements = func.body.statements;
|
|
let classBodyStart = 0;
|
|
let classBodyEnd = -1;
|
|
const statements = [];
|
|
if (aliasAssignment) {
|
|
const extendsCall = tryCast(funcStatements[classBodyStart], isExpressionStatement);
|
|
if (extendsCall) {
|
|
statements.push(extendsCall);
|
|
classBodyStart++;
|
|
}
|
|
statements.push(funcStatements[classBodyStart]);
|
|
classBodyStart++;
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
aliasAssignment.left,
|
|
cast(variable.name, isIdentifier)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
while (!isReturnStatement(elementAt(funcStatements, classBodyEnd))) {
|
|
classBodyEnd--;
|
|
}
|
|
addRange(statements, funcStatements, classBodyStart, classBodyEnd);
|
|
if (classBodyEnd < -1) {
|
|
addRange(statements, funcStatements, classBodyEnd + 1);
|
|
}
|
|
addRange(statements, remainingStatements);
|
|
addRange(statements, classStatements, 1);
|
|
return factory2.restoreOuterExpressions(
|
|
node.expression,
|
|
factory2.restoreOuterExpressions(
|
|
variable.initializer,
|
|
factory2.restoreOuterExpressions(
|
|
aliasAssignment && aliasAssignment.right,
|
|
factory2.updateCallExpression(
|
|
call,
|
|
factory2.restoreOuterExpressions(
|
|
call.expression,
|
|
factory2.updateFunctionExpression(
|
|
func,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
func.parameters,
|
|
void 0,
|
|
factory2.updateBlock(
|
|
func.body,
|
|
statements
|
|
)
|
|
)
|
|
),
|
|
void 0,
|
|
call.arguments
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function visitSuperCallInBody(node) {
|
|
return visitCallExpressionWithPotentialCapturedThisAssignment(node, false);
|
|
}
|
|
function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */ || node.expression.kind === 106 /* SuperKeyword */ || isSuperProperty(skipOuterExpressions(node.expression))) {
|
|
const { target, thisArg } = factory2.createCallBinding(node.expression, hoistVariableDeclaration);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
setEmitFlags(thisArg, 8 /* NoSubstitution */);
|
|
}
|
|
let resultingCall;
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */) {
|
|
resultingCall = factory2.createFunctionApplyCall(
|
|
visitNode(target, callExpressionVisitor, isExpression),
|
|
node.expression.kind === 106 /* SuperKeyword */ ? thisArg : visitNode(thisArg, visitor, isExpression),
|
|
transformAndSpreadElements(node.arguments, true, false, false)
|
|
);
|
|
} else {
|
|
resultingCall = setTextRange(
|
|
factory2.createFunctionCallCall(
|
|
visitNode(target, callExpressionVisitor, isExpression),
|
|
node.expression.kind === 106 /* SuperKeyword */ ? thisArg : visitNode(thisArg, visitor, isExpression),
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
const initializer = factory2.createLogicalOr(
|
|
resultingCall,
|
|
createActualThis()
|
|
);
|
|
resultingCall = assignToCapturedThis ? factory2.createAssignment(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), initializer) : initializer;
|
|
}
|
|
return setOriginalNode(resultingCall, node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNewExpression(node) {
|
|
if (some(node.arguments, isSpreadElement)) {
|
|
const { target, thisArg } = factory2.createCallBinding(factory2.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration);
|
|
return factory2.createNewExpression(
|
|
factory2.createFunctionApplyCall(
|
|
visitNode(target, visitor, isExpression),
|
|
thisArg,
|
|
transformAndSpreadElements(factory2.createNodeArray([factory2.createVoidZero(), ...node.arguments]), true, false, false)
|
|
),
|
|
void 0,
|
|
[]
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndSpreadElements(elements, isArgumentList, multiLine, hasTrailingComma) {
|
|
const numElements = elements.length;
|
|
const segments = flatten(
|
|
spanMap(
|
|
elements,
|
|
partitionSpread,
|
|
(partition, visitPartition, _start, end) => visitPartition(partition, multiLine, hasTrailingComma && end === numElements)
|
|
)
|
|
);
|
|
if (segments.length === 1) {
|
|
const firstSegment = segments[0];
|
|
if (isArgumentList && !compilerOptions.downlevelIteration || isPackedArrayLiteral(firstSegment.expression) || isCallToHelper(firstSegment.expression, "___spreadArray")) {
|
|
return firstSegment.expression;
|
|
}
|
|
}
|
|
const helpers = emitHelpers();
|
|
const startsWithSpread = segments[0].kind !== 0 /* None */;
|
|
let expression = startsWithSpread ? factory2.createArrayLiteralExpression() : segments[0].expression;
|
|
for (let i = startsWithSpread ? 0 : 1; i < segments.length; i++) {
|
|
const segment = segments[i];
|
|
expression = helpers.createSpreadArrayHelper(
|
|
expression,
|
|
segment.expression,
|
|
segment.kind === 1 /* UnpackedSpread */ && !isArgumentList
|
|
);
|
|
}
|
|
return expression;
|
|
}
|
|
function partitionSpread(node) {
|
|
return isSpreadElement(node) ? visitSpanOfSpreads : visitSpanOfNonSpreads;
|
|
}
|
|
function visitSpanOfSpreads(chunk) {
|
|
return map(chunk, visitExpressionOfSpread);
|
|
}
|
|
function visitExpressionOfSpread(node) {
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
const isCallToReadHelper = isCallToHelper(expression, "___read");
|
|
let kind = isCallToReadHelper || isPackedArrayLiteral(expression) ? 2 /* PackedSpread */ : 1 /* UnpackedSpread */;
|
|
if (compilerOptions.downlevelIteration && kind === 1 /* UnpackedSpread */ && !isArrayLiteralExpression(expression) && !isCallToReadHelper) {
|
|
expression = emitHelpers().createReadHelper(expression, void 0);
|
|
kind = 2 /* PackedSpread */;
|
|
}
|
|
return createSpreadSegment(kind, expression);
|
|
}
|
|
function visitSpanOfNonSpreads(chunk, multiLine, hasTrailingComma) {
|
|
const expression = factory2.createArrayLiteralExpression(
|
|
visitNodes2(factory2.createNodeArray(chunk, hasTrailingComma), visitor, isExpression),
|
|
multiLine
|
|
);
|
|
return createSpreadSegment(0 /* None */, expression);
|
|
}
|
|
function visitSpreadElement(node) {
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
function visitTemplateLiteral(node) {
|
|
return setTextRange(factory2.createStringLiteral(node.text), node);
|
|
}
|
|
function visitStringLiteral(node) {
|
|
if (node.hasExtendedUnicodeEscape) {
|
|
return setTextRange(factory2.createStringLiteral(node.text), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitNumericLiteral(node) {
|
|
if (node.numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */) {
|
|
return setTextRange(factory2.createNumericLiteral(node.text), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return processTaggedTemplateExpression(
|
|
context,
|
|
node,
|
|
visitor,
|
|
currentSourceFile,
|
|
recordTaggedTemplateString,
|
|
1 /* All */
|
|
);
|
|
}
|
|
function visitTemplateExpression(node) {
|
|
let expression = factory2.createStringLiteral(node.head.text);
|
|
for (const span of node.templateSpans) {
|
|
const args = [visitNode(span.expression, visitor, isExpression)];
|
|
if (span.literal.text.length > 0) {
|
|
args.push(factory2.createStringLiteral(span.literal.text));
|
|
}
|
|
expression = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(expression, "concat"),
|
|
void 0,
|
|
args
|
|
);
|
|
}
|
|
return setTextRange(expression, node);
|
|
}
|
|
function visitSuperKeyword(isExpressionOfCall) {
|
|
return hierarchyFacts & 8 /* NonStaticClassElement */ && !isExpressionOfCall ? factory2.createPropertyAccessExpression(factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */), "prototype") : factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
}
|
|
function visitMetaProperty(node) {
|
|
if (node.keywordToken === 103 /* NewKeyword */ && node.name.escapedText === "target") {
|
|
hierarchyFacts |= 32768 /* NewTarget */;
|
|
return factory2.createUniqueName("_newTarget", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* CapturedThis */ && isFunctionLike(node)) {
|
|
const ancestorFacts = enterSubtree(
|
|
32670 /* FunctionExcludes */,
|
|
getEmitFlags(node) & 16 /* CapturesThis */ ? 65 /* FunctionIncludes */ | 16 /* CapturesThis */ : 65 /* FunctionIncludes */
|
|
);
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function enableSubstitutionsForBlockScopedBindings() {
|
|
if ((enabledSubstitutions & 2 /* BlockScopedBindings */) === 0) {
|
|
enabledSubstitutions |= 2 /* BlockScopedBindings */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
}
|
|
function enableSubstitutionsForCapturedThis() {
|
|
if ((enabledSubstitutions & 1 /* CapturedThis */) === 0) {
|
|
enabledSubstitutions |= 1 /* CapturedThis */;
|
|
context.enableSubstitution(108 /* ThisKeyword */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(216 /* ArrowFunction */);
|
|
context.enableEmitNotification(215 /* FunctionExpression */);
|
|
context.enableEmitNotification(259 /* FunctionDeclaration */);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
if (isIdentifier(node)) {
|
|
return substituteIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteIdentifier(node) {
|
|
if (enabledSubstitutions & 2 /* BlockScopedBindings */ && !isInternalName(node)) {
|
|
const original = getParseTreeNode(node, isIdentifier);
|
|
if (original && isNameOfDeclarationWithCollidingName(original)) {
|
|
return setTextRange(factory2.getGeneratedNameForNode(original), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function isNameOfDeclarationWithCollidingName(node) {
|
|
switch (node.parent.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 257 /* VariableDeclaration */:
|
|
return node.parent.name === node && resolver.isDeclarationWithCollidingName(node.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 108 /* ThisKeyword */:
|
|
return substituteThisKeyword(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
if (enabledSubstitutions & 2 /* BlockScopedBindings */ && !isInternalName(node)) {
|
|
const declaration = resolver.getReferencedDeclarationWithCollidingName(node);
|
|
if (declaration && !(isClassLike(declaration) && isPartOfClassBody(declaration, node))) {
|
|
return setTextRange(factory2.getGeneratedNameForNode(getNameOfDeclaration(declaration)), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function isPartOfClassBody(declaration, node) {
|
|
let currentNode = getParseTreeNode(node);
|
|
if (!currentNode || currentNode === declaration || currentNode.end <= declaration.pos || currentNode.pos >= declaration.end) {
|
|
return false;
|
|
}
|
|
const blockScope = getEnclosingBlockScopeContainer(declaration);
|
|
while (currentNode) {
|
|
if (currentNode === blockScope || currentNode === declaration) {
|
|
return false;
|
|
}
|
|
if (isClassElement(currentNode) && currentNode.parent === declaration) {
|
|
return true;
|
|
}
|
|
currentNode = currentNode.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function substituteThisKeyword(node) {
|
|
if (enabledSubstitutions & 1 /* CapturedThis */ && hierarchyFacts & 16 /* CapturesThis */) {
|
|
return setTextRange(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), node);
|
|
}
|
|
return node;
|
|
}
|
|
function getClassMemberPrefix(node, member) {
|
|
return isStatic(member) ? factory2.getInternalName(node) : factory2.createPropertyAccessExpression(factory2.getInternalName(node), "prototype");
|
|
}
|
|
function hasSynthesizedDefaultSuperCall(constructor, hasExtendsClause) {
|
|
if (!constructor || !hasExtendsClause) {
|
|
return false;
|
|
}
|
|
if (some(constructor.parameters)) {
|
|
return false;
|
|
}
|
|
const statement = firstOrUndefined(constructor.body.statements);
|
|
if (!statement || !nodeIsSynthesized(statement) || statement.kind !== 241 /* ExpressionStatement */) {
|
|
return false;
|
|
}
|
|
const statementExpression = statement.expression;
|
|
if (!nodeIsSynthesized(statementExpression) || statementExpression.kind !== 210 /* CallExpression */) {
|
|
return false;
|
|
}
|
|
const callTarget = statementExpression.expression;
|
|
if (!nodeIsSynthesized(callTarget) || callTarget.kind !== 106 /* SuperKeyword */) {
|
|
return false;
|
|
}
|
|
const callArgument = singleOrUndefined(statementExpression.arguments);
|
|
if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== 227 /* SpreadElement */) {
|
|
return false;
|
|
}
|
|
const expression = callArgument.expression;
|
|
return isIdentifier(expression) && expression.escapedText === "arguments";
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es5.ts
|
|
function transformES5(context) {
|
|
const { factory: factory2 } = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
let previousOnEmitNode;
|
|
let noSubstitution;
|
|
if (compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */) {
|
|
previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableEmitNotification(283 /* JsxOpeningElement */);
|
|
context.enableEmitNotification(284 /* JsxClosingElement */);
|
|
context.enableEmitNotification(282 /* JsxSelfClosingElement */);
|
|
noSubstitution = [];
|
|
}
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(299 /* PropertyAssignment */);
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
switch (node.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
const tagName = node.tagName;
|
|
noSubstitution[getOriginalNodeId(tagName)] = true;
|
|
break;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
if (node.id && noSubstitution && noSubstitution[node.id]) {
|
|
return previousOnSubstituteNode(hint, node);
|
|
}
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (isPropertyAccessExpression(node)) {
|
|
return substitutePropertyAccessExpression(node);
|
|
} else if (isPropertyAssignment(node)) {
|
|
return substitutePropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
return node;
|
|
}
|
|
const literalName = trySubstituteReservedName(node.name);
|
|
if (literalName) {
|
|
return setTextRange(factory2.createElementAccessExpression(node.expression, literalName), node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAssignment(node) {
|
|
const literalName = isIdentifier(node.name) && trySubstituteReservedName(node.name);
|
|
if (literalName) {
|
|
return factory2.updatePropertyAssignment(node, literalName, node.initializer);
|
|
}
|
|
return node;
|
|
}
|
|
function trySubstituteReservedName(name) {
|
|
const token = name.originalKeywordKind || (nodeIsSynthesized(name) ? stringToToken(idText(name)) : void 0);
|
|
if (token !== void 0 && token >= 81 /* FirstReservedWord */ && token <= 116 /* LastReservedWord */) {
|
|
return setTextRange(factory2.createStringLiteralFromNode(name), name);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/generators.ts
|
|
function getInstructionName(instruction) {
|
|
switch (instruction) {
|
|
case 2 /* Return */:
|
|
return "return";
|
|
case 3 /* Break */:
|
|
return "break";
|
|
case 4 /* Yield */:
|
|
return "yield";
|
|
case 5 /* YieldStar */:
|
|
return "yield*";
|
|
case 7 /* Endfinally */:
|
|
return "endfinally";
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function transformGenerators(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistFunctionDeclaration,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const resolver = context.getEmitResolver();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let renamedCatchVariables;
|
|
let renamedCatchVariableDeclarations;
|
|
let inGeneratorFunctionBody;
|
|
let inStatementContainingYield;
|
|
let blocks;
|
|
let blockOffsets;
|
|
let blockActions;
|
|
let blockStack;
|
|
let labelOffsets;
|
|
let labelExpressions;
|
|
let nextLabelId = 1;
|
|
let operations;
|
|
let operationArguments;
|
|
let operationLocations;
|
|
let state;
|
|
let blockIndex = 0;
|
|
let labelNumber = 0;
|
|
let labelNumbers;
|
|
let lastOperationWasAbrupt;
|
|
let lastOperationWasCompletion;
|
|
let clauses;
|
|
let statements;
|
|
let exceptionBlockStack;
|
|
let currentExceptionBlock;
|
|
let withBlockStack;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || (node.transformFlags & 2048 /* ContainsGenerator */) === 0) {
|
|
return node;
|
|
}
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
const transformFlags = node.transformFlags;
|
|
if (inStatementContainingYield) {
|
|
return visitJavaScriptInStatementContainingYield(node);
|
|
} else if (inGeneratorFunctionBody) {
|
|
return visitJavaScriptInGeneratorFunctionBody(node);
|
|
} else if (isFunctionLikeDeclaration(node) && node.asteriskToken) {
|
|
return visitGenerator(node);
|
|
} else if (transformFlags & 2048 /* ContainsGenerator */) {
|
|
return visitEachChild(node, visitor, context);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitJavaScriptInStatementContainingYield(node) {
|
|
switch (node.kind) {
|
|
case 243 /* DoStatement */:
|
|
return visitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return visitWhileStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
default:
|
|
return visitJavaScriptInGeneratorFunctionBody(node);
|
|
}
|
|
}
|
|
function visitJavaScriptInGeneratorFunctionBody(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return visitAccessorDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return visitBreakStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return visitContinueStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
default:
|
|
if (node.transformFlags & 1048576 /* ContainsYield */) {
|
|
return visitJavaScriptContainingYield(node);
|
|
} else if (node.transformFlags & (2048 /* ContainsGenerator */ | 4194304 /* ContainsHoistedDeclarationOrCompletion */)) {
|
|
return visitEachChild(node, visitor, context);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function visitJavaScriptContainingYield(node) {
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node);
|
|
case 224 /* ConditionalExpression */:
|
|
return visitConditionalExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitArrayLiteralExpression(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitGenerator(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (node.asteriskToken) {
|
|
node = setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionDeclaration(
|
|
node.modifiers,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformGeneratorFunctionBody(node.body)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
if (inGeneratorFunctionBody) {
|
|
hoistFunctionDeclaration(node);
|
|
return void 0;
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
if (node.asteriskToken) {
|
|
node = setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformGeneratorFunctionBody(node.body)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
return node;
|
|
}
|
|
function visitAccessorDeclaration(node) {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
return node;
|
|
}
|
|
function transformGeneratorFunctionBody(body) {
|
|
const statements2 = [];
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
const savedBlocks = blocks;
|
|
const savedBlockOffsets = blockOffsets;
|
|
const savedBlockActions = blockActions;
|
|
const savedBlockStack = blockStack;
|
|
const savedLabelOffsets = labelOffsets;
|
|
const savedLabelExpressions = labelExpressions;
|
|
const savedNextLabelId = nextLabelId;
|
|
const savedOperations = operations;
|
|
const savedOperationArguments = operationArguments;
|
|
const savedOperationLocations = operationLocations;
|
|
const savedState = state;
|
|
inGeneratorFunctionBody = true;
|
|
inStatementContainingYield = false;
|
|
blocks = void 0;
|
|
blockOffsets = void 0;
|
|
blockActions = void 0;
|
|
blockStack = void 0;
|
|
labelOffsets = void 0;
|
|
labelExpressions = void 0;
|
|
nextLabelId = 1;
|
|
operations = void 0;
|
|
operationArguments = void 0;
|
|
operationLocations = void 0;
|
|
state = factory2.createTempVariable(void 0);
|
|
resumeLexicalEnvironment();
|
|
const statementOffset = factory2.copyPrologue(body.statements, statements2, false, visitor);
|
|
transformAndEmitStatements(body.statements, statementOffset);
|
|
const buildResult = build2();
|
|
insertStatementsAfterStandardPrologue(statements2, endLexicalEnvironment());
|
|
statements2.push(factory2.createReturnStatement(buildResult));
|
|
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 setTextRange(factory2.createBlock(statements2, body.multiLine), body);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (node.transformFlags & 1048576 /* ContainsYield */) {
|
|
transformAndEmitVariableDeclarationList(node.declarationList);
|
|
return void 0;
|
|
} else {
|
|
if (getEmitFlags(node) & 2097152 /* CustomPrologue */) {
|
|
return node;
|
|
}
|
|
for (const variable of node.declarationList.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
const variables = getInitializedVariables(node.declarationList);
|
|
if (variables.length === 0) {
|
|
return void 0;
|
|
}
|
|
return setSourceMapRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.inlineExpressions(
|
|
map(variables, transformInitializedVariable)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitBinaryExpression(node) {
|
|
const assoc = getExpressionAssociativity(node);
|
|
switch (assoc) {
|
|
case 0 /* Left */:
|
|
return visitLeftAssociativeBinaryExpression(node);
|
|
case 1 /* Right */:
|
|
return visitRightAssociativeBinaryExpression(node);
|
|
default:
|
|
return Debug.assertNever(assoc);
|
|
}
|
|
}
|
|
function visitRightAssociativeBinaryExpression(node) {
|
|
const { left, right } = node;
|
|
if (containsYield(right)) {
|
|
let target;
|
|
switch (left.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
target = factory2.updatePropertyAccessExpression(
|
|
left,
|
|
cacheExpression(visitNode(left.expression, visitor, isLeftHandSideExpression)),
|
|
left.name
|
|
);
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
target = factory2.updateElementAccessExpression(
|
|
left,
|
|
cacheExpression(visitNode(left.expression, visitor, isLeftHandSideExpression)),
|
|
cacheExpression(visitNode(left.argumentExpression, visitor, isExpression))
|
|
);
|
|
break;
|
|
default:
|
|
target = visitNode(left, visitor, isExpression);
|
|
break;
|
|
}
|
|
const operator = node.operatorToken.kind;
|
|
if (isCompoundAssignment(operator)) {
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
target,
|
|
setTextRange(
|
|
factory2.createBinaryExpression(
|
|
cacheExpression(target),
|
|
getNonAssignmentOperatorForCompoundAssignment(operator),
|
|
visitNode(right, visitor, isExpression)
|
|
),
|
|
node
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return factory2.updateBinaryExpression(node, target, node.operatorToken, visitNode(right, visitor, isExpression));
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitLeftAssociativeBinaryExpression(node) {
|
|
if (containsYield(node.right)) {
|
|
if (isLogicalOperator(node.operatorToken.kind)) {
|
|
return visitLogicalBinaryExpression(node);
|
|
} else if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return visitCommaExpression(node);
|
|
}
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
cacheExpression(visitNode(node.left, visitor, isExpression)),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaExpression(node) {
|
|
let pendingExpressions = [];
|
|
visit(node.left);
|
|
visit(node.right);
|
|
return factory2.inlineExpressions(pendingExpressions);
|
|
function visit(node2) {
|
|
if (isBinaryExpression(node2) && node2.operatorToken.kind === 27 /* CommaToken */) {
|
|
visit(node2.left);
|
|
visit(node2.right);
|
|
} else {
|
|
if (containsYield(node2) && pendingExpressions.length > 0) {
|
|
emitWorker(1 /* Statement */, [factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions))]);
|
|
pendingExpressions = [];
|
|
}
|
|
pendingExpressions.push(visitNode(node2, visitor, isExpression));
|
|
}
|
|
}
|
|
}
|
|
function visitCommaListExpression(node) {
|
|
let pendingExpressions = [];
|
|
for (const elem of node.elements) {
|
|
if (isBinaryExpression(elem) && elem.operatorToken.kind === 27 /* CommaToken */) {
|
|
pendingExpressions.push(visitCommaExpression(elem));
|
|
} else {
|
|
if (containsYield(elem) && pendingExpressions.length > 0) {
|
|
emitWorker(1 /* Statement */, [factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions))]);
|
|
pendingExpressions = [];
|
|
}
|
|
pendingExpressions.push(visitNode(elem, visitor, isExpression));
|
|
}
|
|
}
|
|
return factory2.inlineExpressions(pendingExpressions);
|
|
}
|
|
function visitLogicalBinaryExpression(node) {
|
|
const resultLabel = defineLabel();
|
|
const resultLocal = declareLocal();
|
|
emitAssignment(resultLocal, visitNode(node.left, visitor, isExpression), node.left);
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
emitBreakWhenFalse(resultLabel, resultLocal, node.left);
|
|
} else {
|
|
emitBreakWhenTrue(resultLabel, resultLocal, node.left);
|
|
}
|
|
emitAssignment(resultLocal, visitNode(node.right, visitor, isExpression), node.right);
|
|
markLabel(resultLabel);
|
|
return resultLocal;
|
|
}
|
|
function visitConditionalExpression(node) {
|
|
if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) {
|
|
const whenFalseLabel = defineLabel();
|
|
const resultLabel = defineLabel();
|
|
const resultLocal = declareLocal();
|
|
emitBreakWhenFalse(whenFalseLabel, visitNode(node.condition, visitor, isExpression), node.condition);
|
|
emitAssignment(resultLocal, visitNode(node.whenTrue, visitor, isExpression), node.whenTrue);
|
|
emitBreak(resultLabel);
|
|
markLabel(whenFalseLabel);
|
|
emitAssignment(resultLocal, visitNode(node.whenFalse, visitor, isExpression), node.whenFalse);
|
|
markLabel(resultLabel);
|
|
return resultLocal;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
const resumeLabel = defineLabel();
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
if (node.asteriskToken) {
|
|
const iterator = (getEmitFlags(node.expression) & 16777216 /* Iterator */) === 0 ? setTextRange(emitHelpers().createValuesHelper(expression), node) : expression;
|
|
emitYieldStar(iterator, node);
|
|
} else {
|
|
emitYield(expression, node);
|
|
}
|
|
markLabel(resumeLabel);
|
|
return createGeneratorResume(node);
|
|
}
|
|
function visitArrayLiteralExpression(node) {
|
|
return visitElements(node.elements, void 0, void 0, node.multiLine);
|
|
}
|
|
function visitElements(elements, leadingElement, location, multiLine) {
|
|
const numInitialElements = countInitialNodesWithoutYield(elements);
|
|
let temp;
|
|
if (numInitialElements > 0) {
|
|
temp = declareLocal();
|
|
const initialElements = visitNodes2(elements, visitor, isExpression, 0, numInitialElements);
|
|
emitAssignment(
|
|
temp,
|
|
factory2.createArrayLiteralExpression(
|
|
leadingElement ? [leadingElement, ...initialElements] : initialElements
|
|
)
|
|
);
|
|
leadingElement = void 0;
|
|
}
|
|
const expressions = reduceLeft(elements, reduceElement, [], numInitialElements);
|
|
return temp ? factory2.createArrayConcatCall(temp, [factory2.createArrayLiteralExpression(expressions, multiLine)]) : setTextRange(
|
|
factory2.createArrayLiteralExpression(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine),
|
|
location
|
|
);
|
|
function reduceElement(expressions2, element) {
|
|
if (containsYield(element) && expressions2.length > 0) {
|
|
const hasAssignedTemp = temp !== void 0;
|
|
if (!temp) {
|
|
temp = declareLocal();
|
|
}
|
|
emitAssignment(
|
|
temp,
|
|
hasAssignedTemp ? factory2.createArrayConcatCall(
|
|
temp,
|
|
[factory2.createArrayLiteralExpression(expressions2, multiLine)]
|
|
) : factory2.createArrayLiteralExpression(
|
|
leadingElement ? [leadingElement, ...expressions2] : expressions2,
|
|
multiLine
|
|
)
|
|
);
|
|
leadingElement = void 0;
|
|
expressions2 = [];
|
|
}
|
|
expressions2.push(visitNode(element, visitor, isExpression));
|
|
return expressions2;
|
|
}
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
const properties = node.properties;
|
|
const multiLine = node.multiLine;
|
|
const numInitialProperties = countInitialNodesWithoutYield(properties);
|
|
const temp = declareLocal();
|
|
emitAssignment(
|
|
temp,
|
|
factory2.createObjectLiteralExpression(
|
|
visitNodes2(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
|
|
multiLine
|
|
)
|
|
);
|
|
const expressions = reduceLeft(properties, reduceProperty, [], numInitialProperties);
|
|
expressions.push(multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
|
|
return factory2.inlineExpressions(expressions);
|
|
function reduceProperty(expressions2, property) {
|
|
if (containsYield(property) && expressions2.length > 0) {
|
|
emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(expressions2)));
|
|
expressions2 = [];
|
|
}
|
|
const expression = createExpressionForObjectLiteralElementLike(factory2, node, property, temp);
|
|
const visited = visitNode(expression, visitor, isExpression);
|
|
if (visited) {
|
|
if (multiLine) {
|
|
startOnNewLine(visited);
|
|
}
|
|
expressions2.push(visited);
|
|
}
|
|
return expressions2;
|
|
}
|
|
}
|
|
function visitElementAccessExpression(node) {
|
|
if (containsYield(node.argumentExpression)) {
|
|
return factory2.updateElementAccessExpression(
|
|
node,
|
|
cacheExpression(visitNode(node.expression, visitor, isLeftHandSideExpression)),
|
|
visitNode(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (!isImportCall(node) && forEach(node.arguments, containsYield)) {
|
|
const { target, thisArg } = factory2.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, true);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionApplyCall(
|
|
cacheExpression(visitNode(target, visitor, isLeftHandSideExpression)),
|
|
thisArg,
|
|
visitElements(node.arguments)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNewExpression(node) {
|
|
if (forEach(node.arguments, containsYield)) {
|
|
const { target, thisArg } = factory2.createCallBinding(factory2.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createNewExpression(
|
|
factory2.createFunctionApplyCall(
|
|
cacheExpression(visitNode(target, visitor, isExpression)),
|
|
thisArg,
|
|
visitElements(
|
|
node.arguments,
|
|
factory2.createVoidZero()
|
|
)
|
|
),
|
|
void 0,
|
|
[]
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitStatements(statements2, start = 0) {
|
|
const numStatements = statements2.length;
|
|
for (let i = start; i < numStatements; i++) {
|
|
transformAndEmitStatement(statements2[i]);
|
|
}
|
|
}
|
|
function transformAndEmitEmbeddedStatement(node) {
|
|
if (isBlock(node)) {
|
|
transformAndEmitStatements(node.statements);
|
|
} else {
|
|
transformAndEmitStatement(node);
|
|
}
|
|
}
|
|
function transformAndEmitStatement(node) {
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
if (!inStatementContainingYield) {
|
|
inStatementContainingYield = containsYield(node);
|
|
}
|
|
transformAndEmitStatementWorker(node);
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
function transformAndEmitStatementWorker(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
return transformAndEmitBlock(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return transformAndEmitExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return transformAndEmitIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return transformAndEmitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return transformAndEmitWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return transformAndEmitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return transformAndEmitForInStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return transformAndEmitContinueStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return transformAndEmitBreakStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return transformAndEmitReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return transformAndEmitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return transformAndEmitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return transformAndEmitLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return transformAndEmitThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return transformAndEmitTryStatement(node);
|
|
default:
|
|
return emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitBlock(node) {
|
|
if (containsYield(node)) {
|
|
transformAndEmitStatements(node.statements);
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitExpressionStatement(node) {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
function transformAndEmitVariableDeclarationList(node) {
|
|
for (const variable of node.declarations) {
|
|
const name = factory2.cloneNode(variable.name);
|
|
setCommentRange(name, variable.name);
|
|
hoistVariableDeclaration(name);
|
|
}
|
|
const variables = getInitializedVariables(node);
|
|
const numVariables = variables.length;
|
|
let variablesWritten = 0;
|
|
let pendingExpressions = [];
|
|
while (variablesWritten < numVariables) {
|
|
for (let i = variablesWritten; i < numVariables; i++) {
|
|
const variable = variables[i];
|
|
if (containsYield(variable.initializer) && pendingExpressions.length > 0) {
|
|
break;
|
|
}
|
|
pendingExpressions.push(transformInitializedVariable(variable));
|
|
}
|
|
if (pendingExpressions.length) {
|
|
emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
variablesWritten += pendingExpressions.length;
|
|
pendingExpressions = [];
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
return setSourceMapRange(
|
|
factory2.createAssignment(
|
|
setSourceMapRange(factory2.cloneNode(node.name), node.name),
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitIfStatement(node) {
|
|
if (containsYield(node)) {
|
|
if (containsYield(node.thenStatement) || containsYield(node.elseStatement)) {
|
|
const endLabel = defineLabel();
|
|
const elseLabel = node.elseStatement ? defineLabel() : void 0;
|
|
emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, visitNode(node.expression, visitor, isExpression), node.expression);
|
|
transformAndEmitEmbeddedStatement(node.thenStatement);
|
|
if (node.elseStatement) {
|
|
emitBreak(endLabel);
|
|
markLabel(elseLabel);
|
|
transformAndEmitEmbeddedStatement(node.elseStatement);
|
|
}
|
|
markLabel(endLabel);
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitDoStatement(node) {
|
|
if (containsYield(node)) {
|
|
const conditionLabel = defineLabel();
|
|
const loopLabel = defineLabel();
|
|
beginLoopBlock(conditionLabel);
|
|
markLabel(loopLabel);
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(conditionLabel);
|
|
emitBreakWhenTrue(loopLabel, visitNode(node.expression, visitor, isExpression));
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitDoStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
node = visitEachChild(node, visitor, context);
|
|
endLoopBlock();
|
|
return node;
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformAndEmitWhileStatement(node) {
|
|
if (containsYield(node)) {
|
|
const loopLabel = defineLabel();
|
|
const endLabel = beginLoopBlock(loopLabel);
|
|
markLabel(loopLabel);
|
|
emitBreakWhenFalse(endLabel, visitNode(node.expression, visitor, isExpression));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
emitBreak(loopLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitWhileStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
node = visitEachChild(node, visitor, context);
|
|
endLoopBlock();
|
|
return node;
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformAndEmitForStatement(node) {
|
|
if (containsYield(node)) {
|
|
const conditionLabel = defineLabel();
|
|
const incrementLabel = defineLabel();
|
|
const endLabel = beginLoopBlock(incrementLabel);
|
|
if (node.initializer) {
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
transformAndEmitVariableDeclarationList(initializer);
|
|
} else {
|
|
emitStatement(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
visitNode(initializer, visitor, isExpression)
|
|
),
|
|
initializer
|
|
)
|
|
);
|
|
}
|
|
}
|
|
markLabel(conditionLabel);
|
|
if (node.condition) {
|
|
emitBreakWhenFalse(endLabel, visitNode(node.condition, visitor, isExpression));
|
|
}
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(incrementLabel);
|
|
if (node.incrementor) {
|
|
emitStatement(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
visitNode(node.incrementor, visitor, isExpression)
|
|
),
|
|
node.incrementor
|
|
)
|
|
);
|
|
}
|
|
emitBreak(conditionLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitForStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
}
|
|
const initializer = node.initializer;
|
|
if (initializer && isVariableDeclarationList(initializer)) {
|
|
for (const variable of initializer.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
const variables = getInitializedVariables(initializer);
|
|
node = factory2.updateForStatement(
|
|
node,
|
|
variables.length > 0 ? factory2.inlineExpressions(map(variables, transformInitializedVariable)) : void 0,
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
} else {
|
|
node = visitEachChild(node, visitor, context);
|
|
}
|
|
if (inStatementContainingYield) {
|
|
endLoopBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitForInStatement(node) {
|
|
if (containsYield(node)) {
|
|
const obj = declareLocal();
|
|
const keysArray = declareLocal();
|
|
const key = declareLocal();
|
|
const keysIndex = factory2.createLoopVariable();
|
|
const initializer = node.initializer;
|
|
hoistVariableDeclaration(keysIndex);
|
|
emitAssignment(obj, visitNode(node.expression, visitor, isExpression));
|
|
emitAssignment(keysArray, factory2.createArrayLiteralExpression());
|
|
emitStatement(
|
|
factory2.createForInStatement(
|
|
key,
|
|
obj,
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(keysArray, "push"),
|
|
void 0,
|
|
[key]
|
|
)
|
|
)
|
|
)
|
|
);
|
|
emitAssignment(keysIndex, factory2.createNumericLiteral(0));
|
|
const conditionLabel = defineLabel();
|
|
const incrementLabel = defineLabel();
|
|
const endLoopLabel = beginLoopBlock(incrementLabel);
|
|
markLabel(conditionLabel);
|
|
emitBreakWhenFalse(endLoopLabel, factory2.createLessThan(keysIndex, factory2.createPropertyAccessExpression(keysArray, "length")));
|
|
emitAssignment(key, factory2.createElementAccessExpression(keysArray, keysIndex));
|
|
emitBreakWhenFalse(incrementLabel, factory2.createBinaryExpression(key, 101 /* InKeyword */, obj));
|
|
let variable;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
for (const variable2 of initializer.declarations) {
|
|
hoistVariableDeclaration(variable2.name);
|
|
}
|
|
variable = factory2.cloneNode(initializer.declarations[0].name);
|
|
} else {
|
|
variable = visitNode(initializer, visitor, isExpression);
|
|
Debug.assert(isLeftHandSideExpression(variable));
|
|
}
|
|
emitAssignment(variable, key);
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(incrementLabel);
|
|
emitStatement(factory2.createExpressionStatement(factory2.createPostfixIncrement(keysIndex)));
|
|
emitBreak(conditionLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitForInStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
}
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
for (const variable of initializer.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
node = factory2.updateForInStatement(
|
|
node,
|
|
initializer.declarations[0].name,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.statement, visitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
} else {
|
|
node = visitEachChild(node, visitor, context);
|
|
}
|
|
if (inStatementContainingYield) {
|
|
endLoopBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitContinueStatement(node) {
|
|
const label = findContinueTarget(node.label ? idText(node.label) : void 0);
|
|
if (label > 0) {
|
|
emitBreak(label, node);
|
|
} else {
|
|
emitStatement(node);
|
|
}
|
|
}
|
|
function visitContinueStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
const label = findContinueTarget(node.label && idText(node.label));
|
|
if (label > 0) {
|
|
return createInlineBreak(label, node);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitBreakStatement(node) {
|
|
const label = findBreakTarget(node.label ? idText(node.label) : void 0);
|
|
if (label > 0) {
|
|
emitBreak(label, node);
|
|
} else {
|
|
emitStatement(node);
|
|
}
|
|
}
|
|
function visitBreakStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
const label = findBreakTarget(node.label && idText(node.label));
|
|
if (label > 0) {
|
|
return createInlineBreak(label, node);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitReturnStatement(node) {
|
|
emitReturn(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
return createInlineReturn(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitWithStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginWithBlock(cacheExpression(visitNode(node.expression, visitor, isExpression)));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
endWithBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitSwitchStatement(node) {
|
|
if (containsYield(node.caseBlock)) {
|
|
const caseBlock = node.caseBlock;
|
|
const numClauses = caseBlock.clauses.length;
|
|
const endLabel = beginSwitchBlock();
|
|
const expression = cacheExpression(visitNode(node.expression, visitor, isExpression));
|
|
const clauseLabels = [];
|
|
let defaultClauseIndex = -1;
|
|
for (let i = 0; i < numClauses; i++) {
|
|
const clause = caseBlock.clauses[i];
|
|
clauseLabels.push(defineLabel());
|
|
if (clause.kind === 293 /* DefaultClause */ && defaultClauseIndex === -1) {
|
|
defaultClauseIndex = i;
|
|
}
|
|
}
|
|
let clausesWritten = 0;
|
|
let pendingClauses = [];
|
|
while (clausesWritten < numClauses) {
|
|
let defaultClausesSkipped = 0;
|
|
for (let i = clausesWritten; i < numClauses; i++) {
|
|
const clause = caseBlock.clauses[i];
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
if (containsYield(clause.expression) && pendingClauses.length > 0) {
|
|
break;
|
|
}
|
|
pendingClauses.push(
|
|
factory2.createCaseClause(
|
|
visitNode(clause.expression, visitor, isExpression),
|
|
[
|
|
createInlineBreak(clauseLabels[i], clause.expression)
|
|
]
|
|
)
|
|
);
|
|
} else {
|
|
defaultClausesSkipped++;
|
|
}
|
|
}
|
|
if (pendingClauses.length) {
|
|
emitStatement(factory2.createSwitchStatement(expression, factory2.createCaseBlock(pendingClauses)));
|
|
clausesWritten += pendingClauses.length;
|
|
pendingClauses = [];
|
|
}
|
|
if (defaultClausesSkipped > 0) {
|
|
clausesWritten += defaultClausesSkipped;
|
|
defaultClausesSkipped = 0;
|
|
}
|
|
}
|
|
if (defaultClauseIndex >= 0) {
|
|
emitBreak(clauseLabels[defaultClauseIndex]);
|
|
} else {
|
|
emitBreak(endLabel);
|
|
}
|
|
for (let i = 0; i < numClauses; i++) {
|
|
markLabel(clauseLabels[i]);
|
|
transformAndEmitStatements(caseBlock.clauses[i].statements);
|
|
}
|
|
endSwitchBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptSwitchBlock();
|
|
}
|
|
node = visitEachChild(node, visitor, context);
|
|
if (inStatementContainingYield) {
|
|
endSwitchBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitLabeledStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginLabeledBlock(idText(node.label));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
endLabeledBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLabeledBlock(idText(node.label));
|
|
}
|
|
node = visitEachChild(node, visitor, context);
|
|
if (inStatementContainingYield) {
|
|
endLabeledBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitThrowStatement(node) {
|
|
var _a2;
|
|
emitThrow(
|
|
visitNode((_a2 = node.expression) != null ? _a2 : factory2.createVoidZero(), visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitTryStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginExceptionBlock();
|
|
transformAndEmitEmbeddedStatement(node.tryBlock);
|
|
if (node.catchClause) {
|
|
beginCatchBlock(node.catchClause.variableDeclaration);
|
|
transformAndEmitEmbeddedStatement(node.catchClause.block);
|
|
}
|
|
if (node.finallyBlock) {
|
|
beginFinallyBlock();
|
|
transformAndEmitEmbeddedStatement(node.finallyBlock);
|
|
}
|
|
endExceptionBlock();
|
|
} else {
|
|
emitStatement(visitEachChild(node, visitor, context));
|
|
}
|
|
}
|
|
function containsYield(node) {
|
|
return !!node && (node.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
}
|
|
function countInitialNodesWithoutYield(nodes) {
|
|
const numNodes = nodes.length;
|
|
for (let i = 0; i < numNodes; i++) {
|
|
if (containsYield(nodes[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
if (isIdentifier(node)) {
|
|
return substituteExpressionIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
if (!isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(idText(node))) {
|
|
const original = getOriginalNode(node);
|
|
if (isIdentifier(original) && original.parent) {
|
|
const declaration = resolver.getReferencedValueDeclaration(original);
|
|
if (declaration) {
|
|
const name = renamedCatchVariableDeclarations[getOriginalNodeId(declaration)];
|
|
if (name) {
|
|
const clone2 = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function cacheExpression(node) {
|
|
if (isGeneratedIdentifier(node) || getEmitFlags(node) & 8192 /* HelperName */) {
|
|
return node;
|
|
}
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
emitAssignment(temp, node, node);
|
|
return temp;
|
|
}
|
|
function declareLocal(name) {
|
|
const temp = name ? factory2.createUniqueName(name) : factory2.createTempVariable(void 0);
|
|
hoistVariableDeclaration(temp);
|
|
return temp;
|
|
}
|
|
function defineLabel() {
|
|
if (!labelOffsets) {
|
|
labelOffsets = [];
|
|
}
|
|
const label = nextLabelId;
|
|
nextLabelId++;
|
|
labelOffsets[label] = -1;
|
|
return label;
|
|
}
|
|
function markLabel(label) {
|
|
Debug.assert(labelOffsets !== void 0, "No labels were defined.");
|
|
labelOffsets[label] = operations ? operations.length : 0;
|
|
}
|
|
function beginBlock(block) {
|
|
if (!blocks) {
|
|
blocks = [];
|
|
blockActions = [];
|
|
blockOffsets = [];
|
|
blockStack = [];
|
|
}
|
|
const index = blockActions.length;
|
|
blockActions[index] = 0 /* Open */;
|
|
blockOffsets[index] = operations ? operations.length : 0;
|
|
blocks[index] = block;
|
|
blockStack.push(block);
|
|
return index;
|
|
}
|
|
function endBlock() {
|
|
const block = peekBlock();
|
|
if (block === void 0)
|
|
return Debug.fail("beginBlock was never called.");
|
|
const index = blockActions.length;
|
|
blockActions[index] = 1 /* Close */;
|
|
blockOffsets[index] = operations ? operations.length : 0;
|
|
blocks[index] = block;
|
|
blockStack.pop();
|
|
return block;
|
|
}
|
|
function peekBlock() {
|
|
return lastOrUndefined(blockStack);
|
|
}
|
|
function peekBlockKind() {
|
|
const block = peekBlock();
|
|
return block && block.kind;
|
|
}
|
|
function beginWithBlock(expression) {
|
|
const startLabel = defineLabel();
|
|
const endLabel = defineLabel();
|
|
markLabel(startLabel);
|
|
beginBlock({
|
|
kind: 1 /* With */,
|
|
expression,
|
|
startLabel,
|
|
endLabel
|
|
});
|
|
}
|
|
function endWithBlock() {
|
|
Debug.assert(peekBlockKind() === 1 /* With */);
|
|
const block = endBlock();
|
|
markLabel(block.endLabel);
|
|
}
|
|
function beginExceptionBlock() {
|
|
const startLabel = defineLabel();
|
|
const endLabel = defineLabel();
|
|
markLabel(startLabel);
|
|
beginBlock({
|
|
kind: 0 /* Exception */,
|
|
state: 0 /* Try */,
|
|
startLabel,
|
|
endLabel
|
|
});
|
|
emitNop();
|
|
return endLabel;
|
|
}
|
|
function beginCatchBlock(variable) {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
let name;
|
|
if (isGeneratedIdentifier(variable.name)) {
|
|
name = variable.name;
|
|
hoistVariableDeclaration(variable.name);
|
|
} else {
|
|
const text = idText(variable.name);
|
|
name = declareLocal(text);
|
|
if (!renamedCatchVariables) {
|
|
renamedCatchVariables = /* @__PURE__ */ new Map();
|
|
renamedCatchVariableDeclarations = [];
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
renamedCatchVariables.set(text, true);
|
|
renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name;
|
|
}
|
|
const exception = peekBlock();
|
|
Debug.assert(exception.state < 1 /* Catch */);
|
|
const endLabel = exception.endLabel;
|
|
emitBreak(endLabel);
|
|
const catchLabel = defineLabel();
|
|
markLabel(catchLabel);
|
|
exception.state = 1 /* Catch */;
|
|
exception.catchVariable = name;
|
|
exception.catchLabel = catchLabel;
|
|
emitAssignment(name, factory2.createCallExpression(factory2.createPropertyAccessExpression(state, "sent"), void 0, []));
|
|
emitNop();
|
|
}
|
|
function beginFinallyBlock() {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
const exception = peekBlock();
|
|
Debug.assert(exception.state < 2 /* Finally */);
|
|
const endLabel = exception.endLabel;
|
|
emitBreak(endLabel);
|
|
const finallyLabel = defineLabel();
|
|
markLabel(finallyLabel);
|
|
exception.state = 2 /* Finally */;
|
|
exception.finallyLabel = finallyLabel;
|
|
}
|
|
function endExceptionBlock() {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
const exception = endBlock();
|
|
const state2 = exception.state;
|
|
if (state2 < 2 /* Finally */) {
|
|
emitBreak(exception.endLabel);
|
|
} else {
|
|
emitEndfinally();
|
|
}
|
|
markLabel(exception.endLabel);
|
|
emitNop();
|
|
exception.state = 3 /* Done */;
|
|
}
|
|
function beginScriptLoopBlock() {
|
|
beginBlock({
|
|
kind: 3 /* Loop */,
|
|
isScript: true,
|
|
breakLabel: -1,
|
|
continueLabel: -1
|
|
});
|
|
}
|
|
function beginLoopBlock(continueLabel) {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 3 /* Loop */,
|
|
isScript: false,
|
|
breakLabel,
|
|
continueLabel
|
|
});
|
|
return breakLabel;
|
|
}
|
|
function endLoopBlock() {
|
|
Debug.assert(peekBlockKind() === 3 /* Loop */);
|
|
const block = endBlock();
|
|
const breakLabel = block.breakLabel;
|
|
if (!block.isScript) {
|
|
markLabel(breakLabel);
|
|
}
|
|
}
|
|
function beginScriptSwitchBlock() {
|
|
beginBlock({
|
|
kind: 2 /* Switch */,
|
|
isScript: true,
|
|
breakLabel: -1
|
|
});
|
|
}
|
|
function beginSwitchBlock() {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 2 /* Switch */,
|
|
isScript: false,
|
|
breakLabel
|
|
});
|
|
return breakLabel;
|
|
}
|
|
function endSwitchBlock() {
|
|
Debug.assert(peekBlockKind() === 2 /* Switch */);
|
|
const block = endBlock();
|
|
const breakLabel = block.breakLabel;
|
|
if (!block.isScript) {
|
|
markLabel(breakLabel);
|
|
}
|
|
}
|
|
function beginScriptLabeledBlock(labelText) {
|
|
beginBlock({
|
|
kind: 4 /* Labeled */,
|
|
isScript: true,
|
|
labelText,
|
|
breakLabel: -1
|
|
});
|
|
}
|
|
function beginLabeledBlock(labelText) {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 4 /* Labeled */,
|
|
isScript: false,
|
|
labelText,
|
|
breakLabel
|
|
});
|
|
}
|
|
function endLabeledBlock() {
|
|
Debug.assert(peekBlockKind() === 4 /* Labeled */);
|
|
const block = endBlock();
|
|
if (!block.isScript) {
|
|
markLabel(block.breakLabel);
|
|
}
|
|
}
|
|
function supportsUnlabeledBreak(block) {
|
|
return block.kind === 2 /* Switch */ || block.kind === 3 /* Loop */;
|
|
}
|
|
function supportsLabeledBreakOrContinue(block) {
|
|
return block.kind === 4 /* Labeled */;
|
|
}
|
|
function supportsUnlabeledContinue(block) {
|
|
return block.kind === 3 /* Loop */;
|
|
}
|
|
function hasImmediateContainingLabeledBlock(labelText, start) {
|
|
for (let j = start; j >= 0; j--) {
|
|
const containingBlock = blockStack[j];
|
|
if (supportsLabeledBreakOrContinue(containingBlock)) {
|
|
if (containingBlock.labelText === labelText) {
|
|
return true;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function findBreakTarget(labelText) {
|
|
if (blockStack) {
|
|
if (labelText) {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const 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 (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledBreak(block)) {
|
|
return block.breakLabel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function findContinueTarget(labelText) {
|
|
if (blockStack) {
|
|
if (labelText) {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledContinue(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) {
|
|
return block.continueLabel;
|
|
}
|
|
}
|
|
} else {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledContinue(block)) {
|
|
return block.continueLabel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function createLabel(label) {
|
|
if (label !== void 0 && label > 0) {
|
|
if (labelExpressions === void 0) {
|
|
labelExpressions = [];
|
|
}
|
|
const expression = factory2.createNumericLiteral(-1);
|
|
if (labelExpressions[label] === void 0) {
|
|
labelExpressions[label] = [expression];
|
|
} else {
|
|
labelExpressions[label].push(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
return factory2.createOmittedExpression();
|
|
}
|
|
function createInstruction(instruction) {
|
|
const literal = factory2.createNumericLiteral(instruction);
|
|
addSyntheticTrailingComment(literal, 3 /* MultiLineCommentTrivia */, getInstructionName(instruction));
|
|
return literal;
|
|
}
|
|
function createInlineBreak(label, location) {
|
|
Debug.assertLessThan(0, label, "Invalid label");
|
|
return setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel(label)
|
|
])
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createInlineReturn(expression, location) {
|
|
return setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(2 /* Return */), expression] : [createInstruction(2 /* Return */)]
|
|
)
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function createGeneratorResume(location) {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(state, "sent"),
|
|
void 0,
|
|
[]
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function emitNop() {
|
|
emitWorker(0 /* Nop */);
|
|
}
|
|
function emitStatement(node) {
|
|
if (node) {
|
|
emitWorker(1 /* Statement */, [node]);
|
|
} else {
|
|
emitNop();
|
|
}
|
|
}
|
|
function emitAssignment(left, right, location) {
|
|
emitWorker(2 /* Assign */, [left, right], location);
|
|
}
|
|
function emitBreak(label, location) {
|
|
emitWorker(3 /* Break */, [label], location);
|
|
}
|
|
function emitBreakWhenTrue(label, condition, location) {
|
|
emitWorker(4 /* BreakWhenTrue */, [label, condition], location);
|
|
}
|
|
function emitBreakWhenFalse(label, condition, location) {
|
|
emitWorker(5 /* BreakWhenFalse */, [label, condition], location);
|
|
}
|
|
function emitYieldStar(expression, location) {
|
|
emitWorker(7 /* YieldStar */, [expression], location);
|
|
}
|
|
function emitYield(expression, location) {
|
|
emitWorker(6 /* Yield */, [expression], location);
|
|
}
|
|
function emitReturn(expression, location) {
|
|
emitWorker(8 /* Return */, [expression], location);
|
|
}
|
|
function emitThrow(expression, location) {
|
|
emitWorker(9 /* Throw */, [expression], location);
|
|
}
|
|
function emitEndfinally() {
|
|
emitWorker(10 /* Endfinally */);
|
|
}
|
|
function emitWorker(code, args, location) {
|
|
if (operations === void 0) {
|
|
operations = [];
|
|
operationArguments = [];
|
|
operationLocations = [];
|
|
}
|
|
if (labelOffsets === void 0) {
|
|
markLabel(defineLabel());
|
|
}
|
|
const operationIndex = operations.length;
|
|
operations[operationIndex] = code;
|
|
operationArguments[operationIndex] = args;
|
|
operationLocations[operationIndex] = location;
|
|
}
|
|
function build2() {
|
|
blockIndex = 0;
|
|
labelNumber = 0;
|
|
labelNumbers = void 0;
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
clauses = void 0;
|
|
statements = void 0;
|
|
exceptionBlockStack = void 0;
|
|
currentExceptionBlock = void 0;
|
|
withBlockStack = void 0;
|
|
const buildResult = buildStatements();
|
|
return emitHelpers().createGeneratorHelper(
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, state)],
|
|
void 0,
|
|
factory2.createBlock(
|
|
buildResult,
|
|
buildResult.length > 0
|
|
)
|
|
),
|
|
1048576 /* ReuseTempVariableScope */
|
|
)
|
|
);
|
|
}
|
|
function buildStatements() {
|
|
if (operations) {
|
|
for (let operationIndex = 0; operationIndex < operations.length; operationIndex++) {
|
|
writeOperation(operationIndex);
|
|
}
|
|
flushFinalLabel(operations.length);
|
|
} else {
|
|
flushFinalLabel(0);
|
|
}
|
|
if (clauses) {
|
|
const labelExpression = factory2.createPropertyAccessExpression(state, "label");
|
|
const switchStatement = factory2.createSwitchStatement(labelExpression, factory2.createCaseBlock(clauses));
|
|
return [startOnNewLine(switchStatement)];
|
|
}
|
|
if (statements) {
|
|
return statements;
|
|
}
|
|
return [];
|
|
}
|
|
function flushLabel() {
|
|
if (!statements) {
|
|
return;
|
|
}
|
|
appendLabel(!lastOperationWasAbrupt);
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
labelNumber++;
|
|
}
|
|
function flushFinalLabel(operationIndex) {
|
|
if (isFinalLabelReachable(operationIndex)) {
|
|
tryEnterLabel(operationIndex);
|
|
withBlockStack = void 0;
|
|
writeReturn(void 0, void 0);
|
|
}
|
|
if (statements && clauses) {
|
|
appendLabel(false);
|
|
}
|
|
updateLabelExpressions();
|
|
}
|
|
function isFinalLabelReachable(operationIndex) {
|
|
if (!lastOperationWasCompletion) {
|
|
return true;
|
|
}
|
|
if (!labelOffsets || !labelExpressions) {
|
|
return false;
|
|
}
|
|
for (let label = 0; label < labelOffsets.length; label++) {
|
|
if (labelOffsets[label] === operationIndex && labelExpressions[label]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function appendLabel(markLabelEnd) {
|
|
if (!clauses) {
|
|
clauses = [];
|
|
}
|
|
if (statements) {
|
|
if (withBlockStack) {
|
|
for (let i = withBlockStack.length - 1; i >= 0; i--) {
|
|
const withBlock = withBlockStack[i];
|
|
statements = [factory2.createWithStatement(withBlock.expression, factory2.createBlock(statements))];
|
|
}
|
|
}
|
|
if (currentExceptionBlock) {
|
|
const { startLabel, catchLabel, finallyLabel, endLabel } = currentExceptionBlock;
|
|
statements.unshift(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createPropertyAccessExpression(state, "trys"), "push"),
|
|
void 0,
|
|
[
|
|
factory2.createArrayLiteralExpression([
|
|
createLabel(startLabel),
|
|
createLabel(catchLabel),
|
|
createLabel(finallyLabel),
|
|
createLabel(endLabel)
|
|
])
|
|
]
|
|
)
|
|
)
|
|
);
|
|
currentExceptionBlock = void 0;
|
|
}
|
|
if (markLabelEnd) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(state, "label"),
|
|
factory2.createNumericLiteral(labelNumber + 1)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
clauses.push(
|
|
factory2.createCaseClause(
|
|
factory2.createNumericLiteral(labelNumber),
|
|
statements || []
|
|
)
|
|
);
|
|
statements = void 0;
|
|
}
|
|
function tryEnterLabel(operationIndex) {
|
|
if (!labelOffsets) {
|
|
return;
|
|
}
|
|
for (let label = 0; label < labelOffsets.length; label++) {
|
|
if (labelOffsets[label] === operationIndex) {
|
|
flushLabel();
|
|
if (labelNumbers === void 0) {
|
|
labelNumbers = [];
|
|
}
|
|
if (labelNumbers[labelNumber] === void 0) {
|
|
labelNumbers[labelNumber] = [label];
|
|
} else {
|
|
labelNumbers[labelNumber].push(label);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function updateLabelExpressions() {
|
|
if (labelExpressions !== void 0 && labelNumbers !== void 0) {
|
|
for (let labelNumber2 = 0; labelNumber2 < labelNumbers.length; labelNumber2++) {
|
|
const labels = labelNumbers[labelNumber2];
|
|
if (labels !== void 0) {
|
|
for (const label of labels) {
|
|
const expressions = labelExpressions[label];
|
|
if (expressions !== void 0) {
|
|
for (const expression of expressions) {
|
|
expression.text = String(labelNumber2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function tryEnterOrLeaveBlock(operationIndex) {
|
|
if (blocks) {
|
|
for (; blockIndex < blockActions.length && blockOffsets[blockIndex] <= operationIndex; blockIndex++) {
|
|
const block = blocks[blockIndex];
|
|
const blockAction = blockActions[blockIndex];
|
|
switch (block.kind) {
|
|
case 0 /* Exception */:
|
|
if (blockAction === 0 /* Open */) {
|
|
if (!exceptionBlockStack) {
|
|
exceptionBlockStack = [];
|
|
}
|
|
if (!statements) {
|
|
statements = [];
|
|
}
|
|
exceptionBlockStack.push(currentExceptionBlock);
|
|
currentExceptionBlock = block;
|
|
} else if (blockAction === 1 /* Close */) {
|
|
currentExceptionBlock = exceptionBlockStack.pop();
|
|
}
|
|
break;
|
|
case 1 /* With */:
|
|
if (blockAction === 0 /* Open */) {
|
|
if (!withBlockStack) {
|
|
withBlockStack = [];
|
|
}
|
|
withBlockStack.push(block);
|
|
} else if (blockAction === 1 /* Close */) {
|
|
withBlockStack.pop();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function writeOperation(operationIndex) {
|
|
tryEnterLabel(operationIndex);
|
|
tryEnterOrLeaveBlock(operationIndex);
|
|
if (lastOperationWasAbrupt) {
|
|
return;
|
|
}
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
const opcode = operations[operationIndex];
|
|
if (opcode === 0 /* Nop */) {
|
|
return;
|
|
} else if (opcode === 10 /* Endfinally */) {
|
|
return writeEndfinally();
|
|
}
|
|
const args = operationArguments[operationIndex];
|
|
if (opcode === 1 /* Statement */) {
|
|
return writeStatement(args[0]);
|
|
}
|
|
const location = operationLocations[operationIndex];
|
|
switch (opcode) {
|
|
case 2 /* Assign */:
|
|
return writeAssign(args[0], args[1], location);
|
|
case 3 /* Break */:
|
|
return writeBreak(args[0], location);
|
|
case 4 /* BreakWhenTrue */:
|
|
return writeBreakWhenTrue(args[0], args[1], location);
|
|
case 5 /* BreakWhenFalse */:
|
|
return writeBreakWhenFalse(args[0], args[1], location);
|
|
case 6 /* Yield */:
|
|
return writeYield(args[0], location);
|
|
case 7 /* YieldStar */:
|
|
return writeYieldStar(args[0], location);
|
|
case 8 /* Return */:
|
|
return writeReturn(args[0], location);
|
|
case 9 /* Throw */:
|
|
return writeThrow(args[0], location);
|
|
}
|
|
}
|
|
function writeStatement(statement) {
|
|
if (statement) {
|
|
if (!statements) {
|
|
statements = [statement];
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
}
|
|
function writeAssign(left, right, operationLocation) {
|
|
writeStatement(setTextRange(factory2.createExpressionStatement(factory2.createAssignment(left, right)), operationLocation));
|
|
}
|
|
function writeThrow(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
lastOperationWasCompletion = true;
|
|
writeStatement(setTextRange(factory2.createThrowStatement(expression), operationLocation));
|
|
}
|
|
function writeReturn(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
lastOperationWasCompletion = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(2 /* Return */), expression] : [createInstruction(2 /* Return */)]
|
|
)
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeBreak(label, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeBreakWhenTrue(label, condition, operationLocation) {
|
|
writeStatement(
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
condition,
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
);
|
|
}
|
|
function writeBreakWhenFalse(label, condition, operationLocation) {
|
|
writeStatement(
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalNot(condition),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
);
|
|
}
|
|
function writeYield(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(4 /* Yield */), expression] : [createInstruction(4 /* Yield */)]
|
|
)
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeYieldStar(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(5 /* YieldStar */),
|
|
expression
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeEndfinally() {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(7 /* Endfinally */)
|
|
])
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/module.ts
|
|
function transformModule(context) {
|
|
function getTransformModuleDelegate(moduleKind2) {
|
|
switch (moduleKind2) {
|
|
case 2 /* AMD */:
|
|
return transformAMDModule;
|
|
case 3 /* UMD */:
|
|
return transformUMDModule;
|
|
default:
|
|
return transformCommonJSModule;
|
|
}
|
|
}
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const host = context.getEmitHost();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(212 /* TaggedTemplateExpression */);
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(223 /* BinaryExpression */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
const moduleInfoMap = [];
|
|
const deferredExports = [];
|
|
let currentSourceFile;
|
|
let currentModuleInfo;
|
|
const noSubstitution = [];
|
|
let needUMDDynamicImportHelper;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !(isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 8388608 /* ContainsDynamicImport */ || isJsonSourceFile(node) && hasJsonModuleEmitEnabled(compilerOptions) && outFile(compilerOptions))) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentModuleInfo = collectExternalModuleInfo(context, node, resolver, compilerOptions);
|
|
moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo;
|
|
const transformModule2 = getTransformModuleDelegate(moduleKind);
|
|
const updated = transformModule2(node);
|
|
currentSourceFile = void 0;
|
|
currentModuleInfo = void 0;
|
|
needUMDDynamicImportHelper = false;
|
|
return updated;
|
|
}
|
|
function shouldEmitUnderscoreUnderscoreESModule() {
|
|
if (!currentModuleInfo.exportEquals && isExternalModule(currentSourceFile)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function transformCommonJSModule(node) {
|
|
startLexicalEnvironment();
|
|
const statements = [];
|
|
const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || !compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile);
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, ensureUseStrict && !isJsonSourceFile(node), topLevelVisitor);
|
|
if (shouldEmitUnderscoreUnderscoreESModule()) {
|
|
append(statements, createUnderscoreUnderscoreESModule());
|
|
}
|
|
if (length(currentModuleInfo.exportedNames)) {
|
|
const chunkSize = 50;
|
|
for (let i = 0; i < currentModuleInfo.exportedNames.length; i += chunkSize) {
|
|
append(
|
|
statements,
|
|
factory2.createExpressionStatement(
|
|
reduceLeft(
|
|
currentModuleInfo.exportedNames.slice(i, i + chunkSize),
|
|
(prev, nextId) => factory2.createAssignment(factory2.createPropertyAccessExpression(factory2.createIdentifier("exports"), factory2.createIdentifier(idText(nextId))), prev),
|
|
factory2.createVoidZero()
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement));
|
|
addRange(statements, visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset));
|
|
addExportEqualsIfNeeded(statements, false);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const updated = factory2.updateSourceFile(node, setTextRange(factory2.createNodeArray(statements), node.statements));
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function transformAMDModule(node) {
|
|
const define = factory2.createIdentifier("define");
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const jsonSourceFile = isJsonSourceFile(node) && node;
|
|
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, true);
|
|
const updated = factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
define,
|
|
void 0,
|
|
[
|
|
...moduleName ? [moduleName] : [],
|
|
factory2.createArrayLiteralExpression(jsonSourceFile ? emptyArray : [
|
|
factory2.createStringLiteral("require"),
|
|
factory2.createStringLiteral("exports"),
|
|
...aliasedModuleNames,
|
|
...unaliasedModuleNames
|
|
]),
|
|
jsonSourceFile ? jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory2.createObjectLiteralExpression() : factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, "require"),
|
|
factory2.createParameterDeclaration(void 0, void 0, "exports"),
|
|
...importAliasNames
|
|
],
|
|
void 0,
|
|
transformAsynchronousModuleBody(node)
|
|
)
|
|
]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
);
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function transformUMDModule(node) {
|
|
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, false);
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const umdHeader = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, "factory")],
|
|
void 0,
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
[
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createTypeCheck(factory2.createIdentifier("module"), "object"),
|
|
factory2.createTypeCheck(factory2.createPropertyAccessExpression(factory2.createIdentifier("module"), "exports"), "object")
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
"v",
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("factory"),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("require"),
|
|
factory2.createIdentifier("exports")
|
|
]
|
|
)
|
|
)
|
|
]
|
|
),
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createStrictInequality(
|
|
factory2.createIdentifier("v"),
|
|
factory2.createIdentifier("undefined")
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("module"), "exports"),
|
|
factory2.createIdentifier("v")
|
|
)
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createTypeCheck(factory2.createIdentifier("define"), "function"),
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("define"), "amd")
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("define"),
|
|
void 0,
|
|
[
|
|
...moduleName ? [moduleName] : [],
|
|
factory2.createArrayLiteralExpression([
|
|
factory2.createStringLiteral("require"),
|
|
factory2.createStringLiteral("exports"),
|
|
...aliasedModuleNames,
|
|
...unaliasedModuleNames
|
|
]),
|
|
factory2.createIdentifier("factory")
|
|
]
|
|
)
|
|
)
|
|
])
|
|
)
|
|
)
|
|
],
|
|
true
|
|
),
|
|
void 0
|
|
)
|
|
);
|
|
const updated = factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
umdHeader,
|
|
void 0,
|
|
[
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, "require"),
|
|
factory2.createParameterDeclaration(void 0, void 0, "exports"),
|
|
...importAliasNames
|
|
],
|
|
void 0,
|
|
transformAsynchronousModuleBody(node)
|
|
)
|
|
]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
);
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function collectAsynchronousDependencies(node, includeNonAmdDependencies) {
|
|
const aliasedModuleNames = [];
|
|
const unaliasedModuleNames = [];
|
|
const importAliasNames = [];
|
|
for (const amdDependency of node.amdDependencies) {
|
|
if (amdDependency.name) {
|
|
aliasedModuleNames.push(factory2.createStringLiteral(amdDependency.path));
|
|
importAliasNames.push(factory2.createParameterDeclaration(void 0, void 0, amdDependency.name));
|
|
} else {
|
|
unaliasedModuleNames.push(factory2.createStringLiteral(amdDependency.path));
|
|
}
|
|
}
|
|
for (const importNode of currentModuleInfo.externalImports) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
|
|
const importAliasName = getLocalNameForExternalImport(factory2, importNode, currentSourceFile);
|
|
if (externalModuleName) {
|
|
if (includeNonAmdDependencies && importAliasName) {
|
|
setEmitFlags(importAliasName, 8 /* NoSubstitution */);
|
|
aliasedModuleNames.push(externalModuleName);
|
|
importAliasNames.push(factory2.createParameterDeclaration(void 0, void 0, importAliasName));
|
|
} else {
|
|
unaliasedModuleNames.push(externalModuleName);
|
|
}
|
|
}
|
|
}
|
|
return { aliasedModuleNames, unaliasedModuleNames, importAliasNames };
|
|
}
|
|
function getAMDImportExpressionForImport(node) {
|
|
if (isImportEqualsDeclaration(node) || isExportDeclaration(node) || !getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions)) {
|
|
return void 0;
|
|
}
|
|
const name = getLocalNameForExternalImport(factory2, node, currentSourceFile);
|
|
const expr = getHelperExpressionForImport(node, name);
|
|
if (expr === name) {
|
|
return void 0;
|
|
}
|
|
return factory2.createExpressionStatement(factory2.createAssignment(name, expr));
|
|
}
|
|
function transformAsynchronousModuleBody(node) {
|
|
startLexicalEnvironment();
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, !compilerOptions.noImplicitUseStrict, topLevelVisitor);
|
|
if (shouldEmitUnderscoreUnderscoreESModule()) {
|
|
append(statements, createUnderscoreUnderscoreESModule());
|
|
}
|
|
if (length(currentModuleInfo.exportedNames)) {
|
|
append(statements, factory2.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory2.createAssignment(factory2.createPropertyAccessExpression(factory2.createIdentifier("exports"), factory2.createIdentifier(idText(nextId))), prev), factory2.createVoidZero())));
|
|
}
|
|
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement));
|
|
if (moduleKind === 2 /* AMD */) {
|
|
addRange(statements, mapDefined(currentModuleInfo.externalImports, getAMDImportExpressionForImport));
|
|
}
|
|
addRange(statements, visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset));
|
|
addExportEqualsIfNeeded(statements, true);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const body = factory2.createBlock(statements, true);
|
|
if (needUMDDynamicImportHelper) {
|
|
addEmitHelper(body, dynamicImportUMDHelper);
|
|
}
|
|
return body;
|
|
}
|
|
function addExportEqualsIfNeeded(statements, emitAsReturn) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
const expressionResult = visitNode(currentModuleInfo.exportEquals.expression, visitor);
|
|
if (expressionResult) {
|
|
if (emitAsReturn) {
|
|
const statement = factory2.createReturnStatement(expressionResult);
|
|
setTextRange(statement, currentModuleInfo.exportEquals);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */);
|
|
statements.push(statement);
|
|
} else {
|
|
const statement = factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("module"),
|
|
"exports"
|
|
),
|
|
expressionResult
|
|
)
|
|
);
|
|
setTextRange(statement, currentModuleInfo.exportEquals);
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function topLevelVisitor(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return visitMergeDeclarationMarker(node);
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return visitEndOfDeclarationMarker(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function visitorWorker(node, valueIsDiscarded) {
|
|
if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, valueIsDiscarded);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return visitPartiallyEmittedExpression(node, valueIsDiscarded);
|
|
case 210 /* CallExpression */:
|
|
if (isImportCall(node) && currentSourceFile.impliedNodeFormat === void 0) {
|
|
return visitImportCallExpression(node);
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
return visitDestructuringAssignment(node, valueIsDiscarded);
|
|
}
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, valueIsDiscarded);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function destructuringNeedsFlattening(node) {
|
|
if (isObjectLiteralExpression(node)) {
|
|
for (const elem of node.properties) {
|
|
switch (elem.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
if (destructuringNeedsFlattening(elem.initializer)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (destructuringNeedsFlattening(elem.name)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
if (destructuringNeedsFlattening(elem.expression)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return false;
|
|
default:
|
|
Debug.assertNever(elem, "Unhandled object member kind");
|
|
}
|
|
}
|
|
} else if (isArrayLiteralExpression(node)) {
|
|
for (const elem of node.elements) {
|
|
if (isSpreadElement(elem)) {
|
|
if (destructuringNeedsFlattening(elem.expression)) {
|
|
return true;
|
|
}
|
|
} else if (destructuringNeedsFlattening(elem)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else if (isIdentifier(node)) {
|
|
return length(getExports(node)) > (isExportName(node) ? 1 : 0);
|
|
}
|
|
return false;
|
|
}
|
|
function visitDestructuringAssignment(node, valueIsDiscarded) {
|
|
if (destructuringNeedsFlattening(node.left)) {
|
|
return flattenDestructuringAssignment(node, visitor, context, 0 /* All */, !valueIsDiscarded, createAllExportExpressions);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(
|
|
node,
|
|
visitNode(node.expression, discardedValueVisitor, isExpression)
|
|
);
|
|
}
|
|
function visitParenthesizedExpression(node, valueIsDiscarded) {
|
|
return factory2.updateParenthesizedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPartiallyEmittedExpression(node, valueIsDiscarded) {
|
|
return factory2.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if ((node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand) && !isDeclarationNameOfEnumOrNamespace(node.operand)) {
|
|
const exportedNames = getExports(node.operand);
|
|
if (exportedNames) {
|
|
let temp;
|
|
let expression = visitNode(node.operand, visitor, isExpression);
|
|
if (isPrefixUnaryExpression(node)) {
|
|
expression = factory2.updatePrefixUnaryExpression(node, expression);
|
|
} else {
|
|
expression = factory2.updatePostfixUnaryExpression(node, expression);
|
|
if (!valueIsDiscarded) {
|
|
temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
expression = factory2.createComma(expression, factory2.cloneNode(node.operand));
|
|
setTextRange(expression, node);
|
|
}
|
|
for (const exportName of exportedNames) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = createExportExpression(exportName, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
if (temp) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitImportCallExpression(node) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
|
|
const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor);
|
|
const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
|
|
const containsLexicalThis = !!(node.transformFlags & 16384 /* ContainsLexicalThis */);
|
|
switch (compilerOptions.module) {
|
|
case 2 /* AMD */:
|
|
return createImportCallExpressionAMD(argument, containsLexicalThis);
|
|
case 3 /* UMD */:
|
|
return createImportCallExpressionUMD(argument != null ? argument : factory2.createVoidZero(), containsLexicalThis);
|
|
case 1 /* CommonJS */:
|
|
default:
|
|
return createImportCallExpressionCommonJS(argument);
|
|
}
|
|
}
|
|
function createImportCallExpressionUMD(arg, containsLexicalThis) {
|
|
needUMDDynamicImportHelper = true;
|
|
if (isSimpleCopiableExpression(arg)) {
|
|
const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? factory2.createStringLiteralFromNode(arg) : setEmitFlags(setTextRange(factory2.cloneNode(arg), arg), 3072 /* NoComments */);
|
|
return factory2.createConditionalExpression(
|
|
factory2.createIdentifier("__syncRequire"),
|
|
void 0,
|
|
createImportCallExpressionCommonJS(arg),
|
|
void 0,
|
|
createImportCallExpressionAMD(argClone, containsLexicalThis)
|
|
);
|
|
} else {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
return factory2.createComma(factory2.createAssignment(temp, arg), factory2.createConditionalExpression(
|
|
factory2.createIdentifier("__syncRequire"),
|
|
void 0,
|
|
createImportCallExpressionCommonJS(temp, true),
|
|
void 0,
|
|
createImportCallExpressionAMD(temp, containsLexicalThis)
|
|
));
|
|
}
|
|
}
|
|
function createImportCallExpressionAMD(arg, containsLexicalThis) {
|
|
const resolve = factory2.createUniqueName("resolve");
|
|
const reject = factory2.createUniqueName("reject");
|
|
const parameters = [
|
|
factory2.createParameterDeclaration(void 0, void 0, resolve),
|
|
factory2.createParameterDeclaration(void 0, void 0, reject)
|
|
];
|
|
const body = factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("require"),
|
|
void 0,
|
|
[factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve, reject]
|
|
)
|
|
)
|
|
]);
|
|
let func;
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
func = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
body
|
|
);
|
|
} else {
|
|
func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
if (containsLexicalThis) {
|
|
setEmitFlags(func, 16 /* CapturesThis */);
|
|
}
|
|
}
|
|
const promise = factory2.createNewExpression(factory2.createIdentifier("Promise"), void 0, [func]);
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
return factory2.createCallExpression(factory2.createPropertyAccessExpression(promise, factory2.createIdentifier("then")), void 0, [emitHelpers().createImportStarCallbackHelper()]);
|
|
}
|
|
return promise;
|
|
}
|
|
function createImportCallExpressionCommonJS(arg, isInlineable) {
|
|
const needSyncEval = arg && !isSimpleInlineableExpression(arg) && !isInlineable;
|
|
const promiseResolveCall = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Promise"), "resolve"),
|
|
void 0,
|
|
needSyncEval ? languageVersion >= 2 /* ES2015 */ ? [
|
|
factory2.createTemplateExpression(factory2.createTemplateHead(""), [
|
|
factory2.createTemplateSpan(arg, factory2.createTemplateTail(""))
|
|
])
|
|
] : [
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createStringLiteral(""), "concat"),
|
|
void 0,
|
|
[arg]
|
|
)
|
|
] : []
|
|
);
|
|
let requireCall = factory2.createCallExpression(
|
|
factory2.createIdentifier("require"),
|
|
void 0,
|
|
needSyncEval ? [factory2.createIdentifier("s")] : arg ? [arg] : []
|
|
);
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
requireCall = emitHelpers().createImportStarHelper(requireCall);
|
|
}
|
|
const parameters = needSyncEval ? [
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"s"
|
|
)
|
|
] : [];
|
|
let func;
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
func = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
requireCall
|
|
);
|
|
} else {
|
|
func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
factory2.createBlock([factory2.createReturnStatement(requireCall)])
|
|
);
|
|
}
|
|
const downleveledImport = factory2.createCallExpression(factory2.createPropertyAccessExpression(promiseResolveCall, "then"), void 0, [func]);
|
|
return downleveledImport;
|
|
}
|
|
function getHelperExpressionForExport(node, innerExpr) {
|
|
if (!getESModuleInterop(compilerOptions) || getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) {
|
|
return innerExpr;
|
|
}
|
|
if (getExportNeedsImportStarHelper(node)) {
|
|
return emitHelpers().createImportStarHelper(innerExpr);
|
|
}
|
|
return innerExpr;
|
|
}
|
|
function getHelperExpressionForImport(node, innerExpr) {
|
|
if (!getESModuleInterop(compilerOptions) || getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) {
|
|
return innerExpr;
|
|
}
|
|
if (getImportNeedsImportStarHelper(node)) {
|
|
return emitHelpers().createImportStarHelper(innerExpr);
|
|
}
|
|
if (getImportNeedsImportDefaultHelper(node)) {
|
|
return emitHelpers().createImportDefaultHelper(innerExpr);
|
|
}
|
|
return innerExpr;
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
let statements;
|
|
const namespaceDeclaration = getNamespaceDeclarationNode(node);
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
if (!node.importClause) {
|
|
return setOriginalNode(setTextRange(factory2.createExpressionStatement(createRequireCall(node)), node), node);
|
|
} else {
|
|
const variables = [];
|
|
if (namespaceDeclaration && !isDefaultImport(node)) {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
getHelperExpressionForImport(node, createRequireCall(node))
|
|
)
|
|
);
|
|
} else {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
getHelperExpressionForImport(node, createRequireCall(node))
|
|
)
|
|
);
|
|
if (namespaceDeclaration && isDefaultImport(node)) {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
variables,
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
} else if (namespaceDeclaration && isDefaultImport(node)) {
|
|
statements = append(
|
|
statements,
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
)
|
|
);
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function createRequireCall(importNode) {
|
|
const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
|
|
const args = [];
|
|
if (moduleName) {
|
|
args.push(moduleName);
|
|
}
|
|
return factory2.createCallExpression(factory2.createIdentifier("require"), void 0, args);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
node.name,
|
|
createRequireCall(node)
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(node.name),
|
|
void 0,
|
|
void 0,
|
|
createRequireCall(node)
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(factory2.getExportName(node), factory2.getLocalName(node))
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (!node.moduleSpecifier) {
|
|
return void 0;
|
|
}
|
|
const generatedName = factory2.getGeneratedNameForNode(node);
|
|
if (node.exportClause && isNamedExports(node.exportClause)) {
|
|
const statements = [];
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
generatedName,
|
|
void 0,
|
|
void 0,
|
|
createRequireCall(node)
|
|
)
|
|
])
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
for (const specifier of node.exportClause.elements) {
|
|
if (languageVersion === 0 /* ES3 */) {
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createCreateBindingHelper(generatedName, factory2.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory2.createStringLiteralFromNode(specifier.name) : void 0)
|
|
),
|
|
specifier
|
|
),
|
|
specifier
|
|
)
|
|
);
|
|
} else {
|
|
const exportNeedsImportDefault = !!getESModuleInterop(compilerOptions) && !(getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) && idText(specifier.propertyName || specifier.name) === "default";
|
|
const exportedValue = factory2.createPropertyAccessExpression(
|
|
exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName,
|
|
specifier.propertyName || specifier.name
|
|
);
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(factory2.getExportName(specifier), exportedValue, void 0, true)
|
|
),
|
|
specifier
|
|
),
|
|
specifier
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return singleOrMany(statements);
|
|
} else if (node.exportClause) {
|
|
const statements = [];
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
factory2.cloneNode(node.exportClause.name),
|
|
getHelperExpressionForExport(node, moduleKind !== 2 /* AMD */ ? createRequireCall(node) : isExportNamespaceAsDefaultDeclaration(node) ? generatedName : factory2.createIdentifier(idText(node.exportClause.name)))
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
return singleOrMany(statements);
|
|
} else {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createExportStarHelper(moduleKind !== 2 /* AMD */ ? createRequireCall(node) : generatedName)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitExportAssignment(node) {
|
|
if (node.isExportEquals) {
|
|
return void 0;
|
|
}
|
|
let statements;
|
|
const original = node.original;
|
|
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportStatement(deferredExports[id], factory2.createIdentifier("default"), visitNode(node.expression, visitor), node, true);
|
|
} else {
|
|
statements = appendExportStatement(statements, factory2.createIdentifier("default"), visitNode(node.expression, visitor), node, true);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
let statements;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionDeclaration(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor),
|
|
void 0,
|
|
visitEachChild(node.body, visitor, context)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
let statements;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createClassDeclaration(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor),
|
|
visitNodes2(node.members, visitor)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
let statements;
|
|
let variables;
|
|
let expressions;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
let modifiers;
|
|
let removeCommentsOnExpressions = false;
|
|
for (const variable of node.declarationList.declarations) {
|
|
if (isIdentifier(variable.name) && isLocalName(variable.name)) {
|
|
if (!modifiers) {
|
|
modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
|
|
}
|
|
variables = append(variables, variable);
|
|
} else if (variable.initializer) {
|
|
if (!isBindingPattern(variable.name) && (isArrowFunction(variable.initializer) || isFunctionExpression(variable.initializer) || isClassExpression(variable.initializer))) {
|
|
const expression = factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
variable.name
|
|
),
|
|
variable.name
|
|
),
|
|
factory2.createIdentifier(getTextOfIdentifierOrLiteral(variable.name))
|
|
);
|
|
const updatedVariable = factory2.createVariableDeclaration(
|
|
variable.name,
|
|
variable.exclamationToken,
|
|
variable.type,
|
|
visitNode(variable.initializer, visitor)
|
|
);
|
|
variables = append(variables, updatedVariable);
|
|
expressions = append(expressions, expression);
|
|
removeCommentsOnExpressions = true;
|
|
} else {
|
|
expressions = append(expressions, transformInitializedVariable(variable));
|
|
}
|
|
}
|
|
}
|
|
if (variables) {
|
|
statements = append(statements, factory2.updateVariableStatement(node, modifiers, factory2.updateVariableDeclarationList(node.declarationList, variables)));
|
|
}
|
|
if (expressions) {
|
|
const statement = setOriginalNode(setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(expressions)), node), node);
|
|
if (removeCommentsOnExpressions) {
|
|
removeAllComments(statement);
|
|
}
|
|
statements = append(statements, statement);
|
|
}
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfVariableStatement(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function createAllExportExpressions(name, value, location) {
|
|
const exportedNames = getExports(name);
|
|
if (exportedNames) {
|
|
let expression = isExportName(name) ? value : factory2.createAssignment(name, value);
|
|
for (const exportName of exportedNames) {
|
|
setEmitFlags(expression, 8 /* NoSubstitution */);
|
|
expression = createExportExpression(exportName, expression, location);
|
|
}
|
|
return expression;
|
|
}
|
|
return factory2.createAssignment(name, value);
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
if (isBindingPattern(node.name)) {
|
|
return flattenDestructuringAssignment(
|
|
visitNode(node, visitor),
|
|
void 0,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createAllExportExpressions
|
|
);
|
|
} else {
|
|
return factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
node.name
|
|
),
|
|
node.name
|
|
),
|
|
node.initializer ? visitNode(node.initializer, visitor) : factory2.createVoidZero()
|
|
);
|
|
}
|
|
}
|
|
function visitMergeDeclarationMarker(node) {
|
|
if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* VariableStatement */) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original);
|
|
}
|
|
return node;
|
|
}
|
|
function hasAssociatedEndOfDeclarationMarker(node) {
|
|
return (getEmitFlags(node) & 8388608 /* HasEndOfDeclarationMarker */) !== 0;
|
|
}
|
|
function visitEndOfDeclarationMarker(node) {
|
|
const id = getOriginalNodeId(node);
|
|
const statements = deferredExports[id];
|
|
if (statements) {
|
|
delete deferredExports[id];
|
|
return append(statements, node);
|
|
}
|
|
return node;
|
|
}
|
|
function appendExportsOfImportDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const importClause = decl.importClause;
|
|
if (!importClause) {
|
|
return statements;
|
|
}
|
|
if (importClause.name) {
|
|
statements = appendExportsOfDeclaration(statements, importClause);
|
|
}
|
|
const namedBindings = importClause.namedBindings;
|
|
if (namedBindings) {
|
|
switch (namedBindings.kind) {
|
|
case 271 /* NamespaceImport */:
|
|
statements = appendExportsOfDeclaration(statements, namedBindings);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
for (const importBinding of namedBindings.elements) {
|
|
statements = appendExportsOfDeclaration(statements, importBinding, true);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
return appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
function appendExportsOfVariableStatement(statements, node) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
for (const decl of node.declarationList.declarations) {
|
|
statements = appendExportsOfBindingElement(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfBindingElement(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
statements = appendExportsOfBindingElement(statements, element);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
statements = appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfHoistedDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (hasSyntacticModifier(decl, 1 /* Export */)) {
|
|
const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
|
|
statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl), decl);
|
|
}
|
|
if (decl.name) {
|
|
statements = appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfDeclaration(statements, decl, liveBinding) {
|
|
const name = factory2.getDeclarationName(decl);
|
|
const exportSpecifiers = currentModuleInfo.exportSpecifiers.get(idText(name));
|
|
if (exportSpecifiers) {
|
|
for (const exportSpecifier of exportSpecifiers) {
|
|
statements = appendExportStatement(statements, exportSpecifier.name, name, exportSpecifier.name, void 0, liveBinding);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportStatement(statements, exportName, expression, location, allowComments, liveBinding) {
|
|
statements = append(statements, createExportStatement(exportName, expression, location, allowComments, liveBinding));
|
|
return statements;
|
|
}
|
|
function createUnderscoreUnderscoreESModule() {
|
|
let statement;
|
|
if (languageVersion === 0 /* ES3 */) {
|
|
statement = factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
factory2.createIdentifier("__esModule"),
|
|
factory2.createTrue()
|
|
)
|
|
);
|
|
} else {
|
|
statement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "defineProperty"),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("exports"),
|
|
factory2.createStringLiteral("__esModule"),
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("value", factory2.createTrue())
|
|
])
|
|
]
|
|
)
|
|
);
|
|
}
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
return statement;
|
|
}
|
|
function createExportStatement(name, value, location, allowComments, liveBinding) {
|
|
const statement = setTextRange(factory2.createExpressionStatement(createExportExpression(name, value, void 0, liveBinding)), location);
|
|
startOnNewLine(statement);
|
|
if (!allowComments) {
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
}
|
|
return statement;
|
|
}
|
|
function createExportExpression(name, value, location, liveBinding) {
|
|
return setTextRange(
|
|
liveBinding && languageVersion !== 0 /* ES3 */ ? factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("Object"),
|
|
"defineProperty"
|
|
),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("exports"),
|
|
factory2.createStringLiteralFromNode(name),
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("enumerable", factory2.createTrue()),
|
|
factory2.createPropertyAssignment("get", factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock([factory2.createReturnStatement(value)])
|
|
))
|
|
])
|
|
]
|
|
) : factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
factory2.cloneNode(name)
|
|
),
|
|
value
|
|
),
|
|
location
|
|
);
|
|
}
|
|
function modifierVisitor(node) {
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
currentSourceFile = node;
|
|
currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentSourceFile = void 0;
|
|
currentModuleInfo = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (node.id && noSubstitution[node.id]) {
|
|
return node;
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
const name = node.name;
|
|
const exportedOrImportedName = substituteExpressionIdentifier(name);
|
|
if (exportedOrImportedName !== name) {
|
|
if (node.objectAssignmentInitializer) {
|
|
const initializer = factory2.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer);
|
|
return setTextRange(factory2.createPropertyAssignment(name, initializer), node);
|
|
}
|
|
return setTextRange(factory2.createPropertyAssignment(name, exportedOrImportedName), node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return substituteTaggedTemplateExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return substituteBinaryExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
if (isIdentifier(node.expression)) {
|
|
const expression = substituteExpressionIdentifier(node.expression);
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
if (!isIdentifier(expression) && !(getEmitFlags(node.expression) & 8192 /* HelperName */)) {
|
|
return addEmitFlags(
|
|
factory2.updateCallExpression(
|
|
node,
|
|
expression,
|
|
void 0,
|
|
node.arguments
|
|
),
|
|
1073741824 /* IndirectCall */
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteTaggedTemplateExpression(node) {
|
|
if (isIdentifier(node.tag)) {
|
|
const tag = substituteExpressionIdentifier(node.tag);
|
|
noSubstitution[getNodeId(tag)] = true;
|
|
if (!isIdentifier(tag) && !(getEmitFlags(node.tag) & 8192 /* HelperName */)) {
|
|
return addEmitFlags(
|
|
factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
tag,
|
|
void 0,
|
|
node.template
|
|
),
|
|
1073741824 /* IndirectCall */
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2, _b;
|
|
if (getEmitFlags(node) & 8192 /* HelperName */) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile);
|
|
if (externalHelpersModuleName) {
|
|
return factory2.createPropertyAccessExpression(externalHelpersModuleName, node);
|
|
}
|
|
return node;
|
|
} else if (!(isGeneratedIdentifier(node) && !(node.autoGenerateFlags & 64 /* AllowNameSubstitution */)) && !isLocalName(node)) {
|
|
const exportContainer = resolver.getReferencedExportContainer(node, isExportName(node));
|
|
if (exportContainer && exportContainer.kind === 308 /* SourceFile */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
factory2.cloneNode(node)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(node);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
const name = importDeclaration.propertyName || importDeclaration.name;
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(name)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteBinaryExpression(node) {
|
|
if (isAssignmentOperator(node.operatorToken.kind) && isIdentifier(node.left) && !isGeneratedIdentifier(node.left) && !isLocalName(node.left) && !isDeclarationNameOfEnumOrNamespace(node.left)) {
|
|
const exportedNames = getExports(node.left);
|
|
if (exportedNames) {
|
|
let expression = node;
|
|
for (const exportName of exportedNames) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = createExportExpression(exportName, expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getExports(name) {
|
|
if (!isGeneratedIdentifier(name)) {
|
|
const valueDeclaration = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (valueDeclaration) {
|
|
return currentModuleInfo && currentModuleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var dynamicImportUMDHelper = {
|
|
name: "typescript:dynamicimport-sync-require",
|
|
scoped: true,
|
|
text: `
|
|
var __syncRequire = typeof module === "object" && typeof module.exports === "object";`
|
|
};
|
|
|
|
// src/compiler/transformers/module/system.ts
|
|
function transformSystemModule(context) {
|
|
const {
|
|
factory: factory2,
|
|
startLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const host = context.getEmitHost();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableSubstitution(223 /* BinaryExpression */);
|
|
context.enableSubstitution(233 /* MetaProperty */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
const moduleInfoMap = [];
|
|
const deferredExports = [];
|
|
const exportFunctionsMap = [];
|
|
const noSubstitutionMap = [];
|
|
const contextObjectMap = [];
|
|
let currentSourceFile;
|
|
let moduleInfo;
|
|
let exportFunction;
|
|
let contextObject;
|
|
let hoistedStatements;
|
|
let enclosingBlockScopedContainer;
|
|
let noSubstitution;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !(isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 8388608 /* ContainsDynamicImport */)) {
|
|
return node;
|
|
}
|
|
const id = getOriginalNodeId(node);
|
|
currentSourceFile = node;
|
|
enclosingBlockScopedContainer = node;
|
|
moduleInfo = moduleInfoMap[id] = collectExternalModuleInfo(context, node, resolver, compilerOptions);
|
|
exportFunction = factory2.createUniqueName("exports");
|
|
exportFunctionsMap[id] = exportFunction;
|
|
contextObject = contextObjectMap[id] = factory2.createUniqueName("context");
|
|
const dependencyGroups = collectDependencyGroups(moduleInfo.externalImports);
|
|
const moduleBodyBlock = createSystemModuleBody(node, dependencyGroups);
|
|
const moduleBodyFunction = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, exportFunction),
|
|
factory2.createParameterDeclaration(void 0, void 0, contextObject)
|
|
],
|
|
void 0,
|
|
moduleBodyBlock
|
|
);
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const dependencies = factory2.createArrayLiteralExpression(map(dependencyGroups, (dependencyGroup) => dependencyGroup.name));
|
|
const updated = setEmitFlags(
|
|
factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("System"), "register"),
|
|
void 0,
|
|
moduleName ? [moduleName, dependencies, moduleBodyFunction] : [dependencies, moduleBodyFunction]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
),
|
|
2048 /* NoTrailingComments */
|
|
);
|
|
if (!outFile(compilerOptions)) {
|
|
moveEmitHelpers(updated, moduleBodyBlock, (helper) => !helper.scoped);
|
|
}
|
|
if (noSubstitution) {
|
|
noSubstitutionMap[id] = noSubstitution;
|
|
noSubstitution = void 0;
|
|
}
|
|
currentSourceFile = void 0;
|
|
moduleInfo = void 0;
|
|
exportFunction = void 0;
|
|
contextObject = void 0;
|
|
hoistedStatements = void 0;
|
|
enclosingBlockScopedContainer = void 0;
|
|
return updated;
|
|
}
|
|
function collectDependencyGroups(externalImports) {
|
|
const groupIndices = /* @__PURE__ */ new Map();
|
|
const dependencyGroups = [];
|
|
for (const externalImport of externalImports) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, externalImport, currentSourceFile, host, resolver, compilerOptions);
|
|
if (externalModuleName) {
|
|
const text = externalModuleName.text;
|
|
const groupIndex = groupIndices.get(text);
|
|
if (groupIndex !== void 0) {
|
|
dependencyGroups[groupIndex].externalImports.push(externalImport);
|
|
} else {
|
|
groupIndices.set(text, dependencyGroups.length);
|
|
dependencyGroups.push({
|
|
name: externalModuleName,
|
|
externalImports: [externalImport]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return dependencyGroups;
|
|
}
|
|
function createSystemModuleBody(node, dependencyGroups) {
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || !compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile);
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, ensureUseStrict, topLevelVisitor);
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
"__moduleName",
|
|
void 0,
|
|
void 0,
|
|
factory2.createLogicalAnd(
|
|
contextObject,
|
|
factory2.createPropertyAccessExpression(contextObject, "id")
|
|
)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
visitNode(moduleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement);
|
|
const executeStatements = visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset);
|
|
addRange(statements, hoistedStatements);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const exportStarFunction = addExportStarIfNeeded(statements);
|
|
const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(512 /* Async */) : void 0;
|
|
const moduleObject = factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment(
|
|
"setters",
|
|
createSettersArray(exportStarFunction, dependencyGroups)
|
|
),
|
|
factory2.createPropertyAssignment(
|
|
"execute",
|
|
factory2.createFunctionExpression(
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock(executeStatements, true)
|
|
)
|
|
)
|
|
], true);
|
|
statements.push(factory2.createReturnStatement(moduleObject));
|
|
return factory2.createBlock(statements, true);
|
|
}
|
|
function addExportStarIfNeeded(statements) {
|
|
if (!moduleInfo.hasExportStarsToExportValues) {
|
|
return;
|
|
}
|
|
if (!moduleInfo.exportedNames && moduleInfo.exportSpecifiers.size === 0) {
|
|
let hasExportDeclarationWithExportClause = false;
|
|
for (const externalImport of moduleInfo.externalImports) {
|
|
if (externalImport.kind === 275 /* ExportDeclaration */ && externalImport.exportClause) {
|
|
hasExportDeclarationWithExportClause = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasExportDeclarationWithExportClause) {
|
|
const exportStarFunction2 = createExportStarFunction(void 0);
|
|
statements.push(exportStarFunction2);
|
|
return exportStarFunction2.name;
|
|
}
|
|
}
|
|
const exportedNames = [];
|
|
if (moduleInfo.exportedNames) {
|
|
for (const exportedLocalName of moduleInfo.exportedNames) {
|
|
if (exportedLocalName.escapedText === "default") {
|
|
continue;
|
|
}
|
|
exportedNames.push(
|
|
factory2.createPropertyAssignment(
|
|
factory2.createStringLiteralFromNode(exportedLocalName),
|
|
factory2.createTrue()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
const exportedNamesStorageRef = factory2.createUniqueName("exportedNames");
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
exportedNamesStorageRef,
|
|
void 0,
|
|
void 0,
|
|
factory2.createObjectLiteralExpression(exportedNames, true)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
const exportStarFunction = createExportStarFunction(exportedNamesStorageRef);
|
|
statements.push(exportStarFunction);
|
|
return exportStarFunction.name;
|
|
}
|
|
function createExportStarFunction(localNames) {
|
|
const exportStarFunction = factory2.createUniqueName("exportStar");
|
|
const m = factory2.createIdentifier("m");
|
|
const n = factory2.createIdentifier("n");
|
|
const exports = factory2.createIdentifier("exports");
|
|
let condition = factory2.createStrictInequality(n, factory2.createStringLiteral("default"));
|
|
if (localNames) {
|
|
condition = factory2.createLogicalAnd(
|
|
condition,
|
|
factory2.createLogicalNot(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(localNames, "hasOwnProperty"),
|
|
void 0,
|
|
[n]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
return factory2.createFunctionDeclaration(
|
|
void 0,
|
|
void 0,
|
|
exportStarFunction,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, m)],
|
|
void 0,
|
|
factory2.createBlock([
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
exports,
|
|
void 0,
|
|
void 0,
|
|
factory2.createObjectLiteralExpression([])
|
|
)
|
|
])
|
|
),
|
|
factory2.createForInStatement(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(n)
|
|
]),
|
|
m,
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
condition,
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createElementAccessExpression(exports, n),
|
|
factory2.createElementAccessExpression(m, n)
|
|
)
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
])
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[exports]
|
|
)
|
|
)
|
|
], true)
|
|
);
|
|
}
|
|
function createSettersArray(exportStarFunction, dependencyGroups) {
|
|
const setters = [];
|
|
for (const group2 of dependencyGroups) {
|
|
const localName = forEach(group2.externalImports, (i) => getLocalNameForExternalImport(factory2, i, currentSourceFile));
|
|
const parameterName = localName ? factory2.getGeneratedNameForNode(localName) : factory2.createUniqueName("");
|
|
const statements = [];
|
|
for (const entry of group2.externalImports) {
|
|
const importVariableName = getLocalNameForExternalImport(factory2, entry, currentSourceFile);
|
|
switch (entry.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
if (!entry.importClause) {
|
|
break;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
Debug.assert(importVariableName !== void 0);
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(importVariableName, parameterName)
|
|
)
|
|
);
|
|
if (hasSyntacticModifier(entry, 1 /* Export */)) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(idText(importVariableName)),
|
|
parameterName
|
|
]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
Debug.assert(importVariableName !== void 0);
|
|
if (entry.exportClause) {
|
|
if (isNamedExports(entry.exportClause)) {
|
|
const properties = [];
|
|
for (const e of entry.exportClause.elements) {
|
|
properties.push(
|
|
factory2.createPropertyAssignment(
|
|
factory2.createStringLiteral(idText(e.name)),
|
|
factory2.createElementAccessExpression(
|
|
parameterName,
|
|
factory2.createStringLiteral(idText(e.propertyName || e.name))
|
|
)
|
|
)
|
|
);
|
|
}
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[factory2.createObjectLiteralExpression(properties, true)]
|
|
)
|
|
)
|
|
);
|
|
} else {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(idText(entry.exportClause.name)),
|
|
parameterName
|
|
]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportStarFunction,
|
|
void 0,
|
|
[parameterName]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
setters.push(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
factory2.createBlock(statements, true)
|
|
)
|
|
);
|
|
}
|
|
return factory2.createArrayLiteralExpression(setters, true);
|
|
}
|
|
function topLevelVisitor(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
default:
|
|
return topLevelNestedVisitor(node);
|
|
}
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
let statements;
|
|
if (node.importClause) {
|
|
hoistVariableDeclaration(getLocalNameForExternalImport(factory2, node, currentSourceFile));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
Debug.assertIsDefined(node);
|
|
return void 0;
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
hoistVariableDeclaration(getLocalNameForExternalImport(factory2, node, currentSourceFile));
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportAssignment(node) {
|
|
if (node.isExportEquals) {
|
|
return void 0;
|
|
}
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const original = node.original;
|
|
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportStatement(deferredExports[id], factory2.createIdentifier("default"), expression, true);
|
|
} else {
|
|
return createExportStatement(factory2.createIdentifier("default"), expression, true);
|
|
}
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
hoistedStatements = append(
|
|
hoistedStatements,
|
|
factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
node.asteriskToken,
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
)
|
|
);
|
|
} else {
|
|
hoistedStatements = append(hoistedStatements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
let statements;
|
|
const name = factory2.getLocalName(node);
|
|
hoistVariableDeclaration(name);
|
|
statements = append(
|
|
statements,
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
name,
|
|
setTextRange(
|
|
factory2.createClassExpression(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, visitor, isClassElement)
|
|
),
|
|
node
|
|
)
|
|
)
|
|
),
|
|
node
|
|
)
|
|
);
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (!shouldHoistVariableDeclarationList(node.declarationList)) {
|
|
return visitNode(node, visitor, isStatement);
|
|
}
|
|
let expressions;
|
|
const isExportedDeclaration = hasSyntacticModifier(node, 1 /* Export */);
|
|
const isMarkedDeclaration = hasAssociatedEndOfDeclarationMarker(node);
|
|
for (const variable of node.declarationList.declarations) {
|
|
if (variable.initializer) {
|
|
expressions = append(expressions, transformInitializedVariable(variable, isExportedDeclaration && !isMarkedDeclaration));
|
|
} else {
|
|
hoistBindingElement(variable);
|
|
}
|
|
}
|
|
let statements;
|
|
if (expressions) {
|
|
statements = append(statements, setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(expressions)), node));
|
|
}
|
|
if (isMarkedDeclaration) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration);
|
|
} else {
|
|
statements = appendExportsOfVariableStatement(statements, node, false);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function hoistBindingElement(node) {
|
|
if (isBindingPattern(node.name)) {
|
|
for (const element of node.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
hoistBindingElement(element);
|
|
}
|
|
}
|
|
} else {
|
|
hoistVariableDeclaration(factory2.cloneNode(node.name));
|
|
}
|
|
}
|
|
function shouldHoistVariableDeclarationList(node) {
|
|
return (getEmitFlags(node) & 4194304 /* NoHoisting */) === 0 && (enclosingBlockScopedContainer.kind === 308 /* SourceFile */ || (getOriginalNode(node).flags & 3 /* BlockScoped */) === 0);
|
|
}
|
|
function transformInitializedVariable(node, isExportedDeclaration) {
|
|
const createAssignment = isExportedDeclaration ? createExportedVariableAssignment : createNonExportedVariableAssignment;
|
|
return isBindingPattern(node.name) ? flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createAssignment
|
|
) : node.initializer ? createAssignment(node.name, visitNode(node.initializer, visitor, isExpression)) : node.name;
|
|
}
|
|
function createExportedVariableAssignment(name, value, location) {
|
|
return createVariableAssignment(name, value, location, true);
|
|
}
|
|
function createNonExportedVariableAssignment(name, value, location) {
|
|
return createVariableAssignment(name, value, location, false);
|
|
}
|
|
function createVariableAssignment(name, value, location, isExportedDeclaration) {
|
|
hoistVariableDeclaration(factory2.cloneNode(name));
|
|
return isExportedDeclaration ? createExportExpression(name, preventSubstitution(setTextRange(factory2.createAssignment(name, value), location))) : preventSubstitution(setTextRange(factory2.createAssignment(name, value), location));
|
|
}
|
|
function visitMergeDeclarationMarker(node) {
|
|
if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* VariableStatement */) {
|
|
const id = getOriginalNodeId(node);
|
|
const isExportedDeclaration = hasSyntacticModifier(node.original, 1 /* Export */);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original, isExportedDeclaration);
|
|
}
|
|
return node;
|
|
}
|
|
function hasAssociatedEndOfDeclarationMarker(node) {
|
|
return (getEmitFlags(node) & 8388608 /* HasEndOfDeclarationMarker */) !== 0;
|
|
}
|
|
function visitEndOfDeclarationMarker(node) {
|
|
const id = getOriginalNodeId(node);
|
|
const statements = deferredExports[id];
|
|
if (statements) {
|
|
delete deferredExports[id];
|
|
return append(statements, node);
|
|
} else {
|
|
const original = getOriginalNode(node);
|
|
if (isModuleOrEnumDeclaration(original)) {
|
|
return append(appendExportsOfDeclaration(statements, original), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function appendExportsOfImportDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const importClause = decl.importClause;
|
|
if (!importClause) {
|
|
return statements;
|
|
}
|
|
if (importClause.name) {
|
|
statements = appendExportsOfDeclaration(statements, importClause);
|
|
}
|
|
const namedBindings = importClause.namedBindings;
|
|
if (namedBindings) {
|
|
switch (namedBindings.kind) {
|
|
case 271 /* NamespaceImport */:
|
|
statements = appendExportsOfDeclaration(statements, namedBindings);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
for (const importBinding of namedBindings.elements) {
|
|
statements = appendExportsOfDeclaration(statements, importBinding);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
return appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
function appendExportsOfVariableStatement(statements, node, exportSelf) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
for (const decl of node.declarationList.declarations) {
|
|
if (decl.initializer || exportSelf) {
|
|
statements = appendExportsOfBindingElement(statements, decl, exportSelf);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfBindingElement(statements, decl, exportSelf) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
statements = appendExportsOfBindingElement(statements, element, exportSelf);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
let excludeName;
|
|
if (exportSelf) {
|
|
statements = appendExportStatement(statements, decl.name, factory2.getLocalName(decl));
|
|
excludeName = idText(decl.name);
|
|
}
|
|
statements = appendExportsOfDeclaration(statements, decl, excludeName);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfHoistedDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
let excludeName;
|
|
if (hasSyntacticModifier(decl, 1 /* Export */)) {
|
|
const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
|
|
statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl));
|
|
excludeName = getTextOfIdentifierOrLiteral(exportName);
|
|
}
|
|
if (decl.name) {
|
|
statements = appendExportsOfDeclaration(statements, decl, excludeName);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfDeclaration(statements, decl, excludeName) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const name = factory2.getDeclarationName(decl);
|
|
const exportSpecifiers = moduleInfo.exportSpecifiers.get(idText(name));
|
|
if (exportSpecifiers) {
|
|
for (const exportSpecifier of exportSpecifiers) {
|
|
if (exportSpecifier.name.escapedText !== excludeName) {
|
|
statements = appendExportStatement(statements, exportSpecifier.name, name);
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportStatement(statements, exportName, expression, allowComments) {
|
|
statements = append(statements, createExportStatement(exportName, expression, allowComments));
|
|
return statements;
|
|
}
|
|
function createExportStatement(name, value, allowComments) {
|
|
const statement = factory2.createExpressionStatement(createExportExpression(name, value));
|
|
startOnNewLine(statement);
|
|
if (!allowComments) {
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
}
|
|
return statement;
|
|
}
|
|
function createExportExpression(name, value) {
|
|
const exportName = isIdentifier(name) ? factory2.createStringLiteralFromNode(name) : name;
|
|
setEmitFlags(value, getEmitFlags(value) | 3072 /* NoComments */);
|
|
return setCommentRange(factory2.createCallExpression(exportFunction, void 0, [exportName, value]), value);
|
|
}
|
|
function topLevelNestedVisitor(node) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, true);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return visitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return visitWhileStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return visitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 266 /* CaseBlock */:
|
|
return visitCaseBlock(node);
|
|
case 292 /* CaseClause */:
|
|
return visitCaseClause(node);
|
|
case 293 /* DefaultClause */:
|
|
return visitDefaultClause(node);
|
|
case 255 /* TryStatement */:
|
|
return visitTryStatement(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 238 /* Block */:
|
|
return visitBlock(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return visitMergeDeclarationMarker(node);
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return visitEndOfDeclarationMarker(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function visitForStatement(node, isTopLevel) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, isTopLevel ? visitForInitializer : discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitForInStatement(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForInStatement(
|
|
node,
|
|
visitForInitializer(node.initializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitForOfStatement(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForOfStatement(
|
|
node,
|
|
node.awaitModifier,
|
|
visitForInitializer(node.initializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function shouldHoistForInitializer(node) {
|
|
return isVariableDeclarationList(node) && shouldHoistVariableDeclarationList(node);
|
|
}
|
|
function visitForInitializer(node) {
|
|
if (shouldHoistForInitializer(node)) {
|
|
let expressions;
|
|
for (const variable of node.declarations) {
|
|
expressions = append(expressions, transformInitializedVariable(variable, false));
|
|
if (!variable.initializer) {
|
|
hoistBindingElement(variable);
|
|
}
|
|
}
|
|
return expressions ? factory2.inlineExpressions(expressions) : factory2.createOmittedExpression();
|
|
} else {
|
|
return visitNode(node, discardedValueVisitor, isExpression);
|
|
}
|
|
}
|
|
function visitDoStatement(node) {
|
|
return factory2.updateDoStatement(
|
|
node,
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context),
|
|
visitNode(node.expression, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitWhileStatement(node) {
|
|
return factory2.updateWhileStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
return factory2.updateLabeledStatement(
|
|
node,
|
|
node.label,
|
|
visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitWithStatement(node) {
|
|
return factory2.updateWithStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
return factory2.updateSwitchStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.caseBlock, topLevelNestedVisitor, isCaseBlock)
|
|
);
|
|
}
|
|
function visitCaseBlock(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateCaseBlock(
|
|
node,
|
|
visitNodes2(node.clauses, topLevelNestedVisitor, isCaseOrDefaultClause)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitCaseClause(node) {
|
|
return factory2.updateCaseClause(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNodes2(node.statements, topLevelNestedVisitor, isStatement)
|
|
);
|
|
}
|
|
function visitDefaultClause(node) {
|
|
return visitEachChild(node, topLevelNestedVisitor, context);
|
|
}
|
|
function visitTryStatement(node) {
|
|
return visitEachChild(node, topLevelNestedVisitor, context);
|
|
}
|
|
function visitCatchClause(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateCatchClause(
|
|
node,
|
|
node.variableDeclaration,
|
|
visitNode(node.block, topLevelNestedVisitor, isBlock)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitBlock(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = visitEachChild(node, topLevelNestedVisitor, context);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitorWorker(node, valueIsDiscarded) {
|
|
if (!(node.transformFlags & (4096 /* ContainsDestructuringAssignment */ | 8388608 /* ContainsDynamicImport */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, false);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, valueIsDiscarded);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return visitPartiallyEmittedExpression(node, valueIsDiscarded);
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
return visitDestructuringAssignment(node, valueIsDiscarded);
|
|
}
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
if (isImportCall(node)) {
|
|
return visitImportCallExpression(node);
|
|
}
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(node, visitNode(node.expression, discardedValueVisitor, isExpression));
|
|
}
|
|
function visitParenthesizedExpression(node, valueIsDiscarded) {
|
|
return factory2.updateParenthesizedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPartiallyEmittedExpression(node, valueIsDiscarded) {
|
|
return factory2.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitImportCallExpression(node) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
|
|
const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor);
|
|
const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
contextObject,
|
|
factory2.createIdentifier("import")
|
|
),
|
|
void 0,
|
|
argument ? [argument] : []
|
|
);
|
|
}
|
|
function visitDestructuringAssignment(node, valueIsDiscarded) {
|
|
if (hasExportedReferenceInDestructuringTarget(node.left)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
!valueIsDiscarded
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function hasExportedReferenceInDestructuringTarget(node) {
|
|
if (isAssignmentExpression(node, true)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.left);
|
|
} else if (isSpreadElement(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.expression);
|
|
} else if (isObjectLiteralExpression(node)) {
|
|
return some(node.properties, hasExportedReferenceInDestructuringTarget);
|
|
} else if (isArrayLiteralExpression(node)) {
|
|
return some(node.elements, hasExportedReferenceInDestructuringTarget);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.name);
|
|
} else if (isPropertyAssignment(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.initializer);
|
|
} else if (isIdentifier(node)) {
|
|
const container = resolver.getReferencedExportContainer(node);
|
|
return container !== void 0 && container.kind === 308 /* SourceFile */;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
function visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if ((node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand) && !isDeclarationNameOfEnumOrNamespace(node.operand)) {
|
|
const exportedNames = getExports(node.operand);
|
|
if (exportedNames) {
|
|
let temp;
|
|
let expression = visitNode(node.operand, visitor, isExpression);
|
|
if (isPrefixUnaryExpression(node)) {
|
|
expression = factory2.updatePrefixUnaryExpression(node, expression);
|
|
} else {
|
|
expression = factory2.updatePostfixUnaryExpression(node, expression);
|
|
if (!valueIsDiscarded) {
|
|
temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
expression = factory2.createComma(expression, factory2.cloneNode(node.operand));
|
|
setTextRange(expression, node);
|
|
}
|
|
for (const exportName of exportedNames) {
|
|
expression = createExportExpression(exportName, preventSubstitution(expression));
|
|
}
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function modifierVisitor(node) {
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
const id = 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 = void 0;
|
|
moduleInfo = void 0;
|
|
exportFunction = void 0;
|
|
contextObject = void 0;
|
|
noSubstitution = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (isSubstitutionPrevented(node)) {
|
|
return node;
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (hint === 4 /* Unspecified */) {
|
|
return substituteUnspecified(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteUnspecified(node) {
|
|
switch (node.kind) {
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
var _a2, _b;
|
|
const name = node.name;
|
|
if (!isGeneratedIdentifier(name) && !isLocalName(name)) {
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(name);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
factory2.cloneNode(name),
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
factory2.cloneNode(name),
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(importDeclaration.propertyName || importDeclaration.name)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 223 /* BinaryExpression */:
|
|
return substituteBinaryExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return substituteMetaProperty(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2, _b;
|
|
if (getEmitFlags(node) & 8192 /* HelperName */) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile);
|
|
if (externalHelpersModuleName) {
|
|
return factory2.createPropertyAccessExpression(externalHelpersModuleName, node);
|
|
}
|
|
return node;
|
|
}
|
|
if (!isGeneratedIdentifier(node) && !isLocalName(node)) {
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(node);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(importDeclaration.propertyName || importDeclaration.name)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteBinaryExpression(node) {
|
|
if (isAssignmentOperator(node.operatorToken.kind) && isIdentifier(node.left) && !isGeneratedIdentifier(node.left) && !isLocalName(node.left) && !isDeclarationNameOfEnumOrNamespace(node.left)) {
|
|
const exportedNames = getExports(node.left);
|
|
if (exportedNames) {
|
|
let expression = node;
|
|
for (const exportName of exportedNames) {
|
|
expression = createExportExpression(exportName, preventSubstitution(expression));
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteMetaProperty(node) {
|
|
if (isImportMeta(node)) {
|
|
return factory2.createPropertyAccessExpression(contextObject, factory2.createIdentifier("meta"));
|
|
}
|
|
return node;
|
|
}
|
|
function getExports(name) {
|
|
let exportedNames;
|
|
if (!isGeneratedIdentifier(name)) {
|
|
const valueDeclaration = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (valueDeclaration) {
|
|
const exportContainer = resolver.getReferencedExportContainer(name, false);
|
|
if (exportContainer && exportContainer.kind === 308 /* SourceFile */) {
|
|
exportedNames = append(exportedNames, factory2.getDeclarationName(valueDeclaration));
|
|
}
|
|
exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)]);
|
|
}
|
|
}
|
|
return exportedNames;
|
|
}
|
|
function preventSubstitution(node) {
|
|
if (noSubstitution === void 0)
|
|
noSubstitution = [];
|
|
noSubstitution[getNodeId(node)] = true;
|
|
return node;
|
|
}
|
|
function isSubstitutionPrevented(node) {
|
|
return noSubstitution && node.id && noSubstitution[node.id];
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/esnextAnd2015.ts
|
|
function transformECMAScriptModule(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers
|
|
} = context;
|
|
const host = context.getEmitHost();
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
let helperNameSubstitutions;
|
|
let currentSourceFile;
|
|
let importRequireStatements;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
if (isExternalModule(node) || compilerOptions.isolatedModules) {
|
|
currentSourceFile = node;
|
|
importRequireStatements = void 0;
|
|
let result = updateExternalModule(node);
|
|
currentSourceFile = void 0;
|
|
if (importRequireStatements) {
|
|
result = factory2.updateSourceFile(
|
|
result,
|
|
setTextRange(factory2.createNodeArray(insertStatementsAfterCustomPrologue(result.statements.slice(), importRequireStatements)), result.statements)
|
|
);
|
|
}
|
|
if (!isExternalModule(node) || some(result.statements, isExternalModuleIndicator)) {
|
|
return result;
|
|
}
|
|
return factory2.updateSourceFile(
|
|
result,
|
|
setTextRange(factory2.createNodeArray([...result.statements, createEmptyExports(factory2)]), result.statements)
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function updateExternalModule(node) {
|
|
const externalHelpersImportDeclaration = createExternalHelpersImportDeclarationIfNeeded(factory2, emitHelpers(), node, compilerOptions);
|
|
if (externalHelpersImportDeclaration) {
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements);
|
|
append(statements, externalHelpersImportDeclaration);
|
|
addRange(statements, visitNodes2(node.statements, visitor, isStatement, statementOffset));
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(factory2.createNodeArray(statements), node.statements)
|
|
);
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitor(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return getEmitModuleKind(compilerOptions) >= 100 /* Node16 */ ? visitImportEqualsDeclaration(node) : void 0;
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
const exportDecl = node;
|
|
return visitExportDeclaration(exportDecl);
|
|
}
|
|
return node;
|
|
}
|
|
function createRequireCall(importNode) {
|
|
const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions);
|
|
const args = [];
|
|
if (moduleName) {
|
|
args.push(moduleName);
|
|
}
|
|
if (!importRequireStatements) {
|
|
const createRequireName = factory2.createUniqueName("_createRequire", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
const importStatement = factory2.createImportDeclaration(
|
|
void 0,
|
|
factory2.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory2.createNamedImports([
|
|
factory2.createImportSpecifier(false, factory2.createIdentifier("createRequire"), createRequireName)
|
|
])
|
|
),
|
|
factory2.createStringLiteral("module")
|
|
);
|
|
const requireHelperName = factory2.createUniqueName("__require", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
const requireStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
requireHelperName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(factory2.cloneNode(createRequireName), void 0, [
|
|
factory2.createPropertyAccessExpression(factory2.createMetaProperty(100 /* ImportKeyword */, factory2.createIdentifier("meta")), factory2.createIdentifier("url"))
|
|
])
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
);
|
|
importRequireStatements = [importStatement, requireStatement];
|
|
}
|
|
const name = importRequireStatements[1].declarationList.declarations[0].name;
|
|
Debug.assertNode(name, isIdentifier);
|
|
return factory2.createCallExpression(factory2.cloneNode(name), void 0, args);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(node.name),
|
|
void 0,
|
|
void 0,
|
|
createRequireCall(node)
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
return singleOrMany(statements);
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(statements, factory2.createExportDeclaration(
|
|
void 0,
|
|
node.isTypeOnly,
|
|
factory2.createNamedExports([factory2.createExportSpecifier(false, void 0, idText(node.name))])
|
|
));
|
|
}
|
|
return statements;
|
|
}
|
|
function visitExportAssignment(node) {
|
|
return node.isExportEquals ? void 0 : node;
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */) {
|
|
return node;
|
|
}
|
|
if (!node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) {
|
|
return node;
|
|
}
|
|
const oldIdentifier = node.exportClause.name;
|
|
const synthName = factory2.getGeneratedNameForNode(oldIdentifier);
|
|
const importDecl = factory2.createImportDeclaration(
|
|
void 0,
|
|
factory2.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory2.createNamespaceImport(
|
|
synthName
|
|
)
|
|
),
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
);
|
|
setOriginalNode(importDecl, node.exportClause);
|
|
const exportDecl = isExportNamespaceAsDefaultDeclaration(node) ? factory2.createExportDefault(synthName) : factory2.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory2.createNamedExports([factory2.createExportSpecifier(false, synthName, oldIdentifier)])
|
|
);
|
|
setOriginalNode(exportDecl, node);
|
|
return [importDecl, exportDecl];
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (isSourceFile(node)) {
|
|
if ((isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) {
|
|
helperNameSubstitutions = /* @__PURE__ */ new Map();
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
helperNameSubstitutions = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (helperNameSubstitutions && isIdentifier(node) && getEmitFlags(node) & 8192 /* HelperName */) {
|
|
return substituteHelperName(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteHelperName(node) {
|
|
const name = idText(node);
|
|
let substitution = helperNameSubstitutions.get(name);
|
|
if (!substitution) {
|
|
helperNameSubstitutions.set(name, substitution = factory2.createUniqueName(name, 16 /* Optimistic */ | 32 /* FileLevel */));
|
|
}
|
|
return substitution;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/node.ts
|
|
function transformNodeModule(context) {
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const esmTransform = transformECMAScriptModule(context);
|
|
const esmOnSubstituteNode = context.onSubstituteNode;
|
|
const esmOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = previousOnSubstituteNode;
|
|
context.onEmitNode = previousOnEmitNode;
|
|
const cjsTransform = transformModule(context);
|
|
const cjsOnSubstituteNode = context.onSubstituteNode;
|
|
const cjsOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(308 /* SourceFile */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
let currentSourceFile;
|
|
return transformSourceFileOrBundle;
|
|
function onSubstituteNode(hint, node) {
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
return previousOnSubstituteNode(hint, node);
|
|
} else {
|
|
if (!currentSourceFile) {
|
|
return previousOnSubstituteNode(hint, node);
|
|
}
|
|
if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
return esmOnSubstituteNode(hint, node);
|
|
}
|
|
return cjsOnSubstituteNode(hint, node);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
}
|
|
if (!currentSourceFile) {
|
|
return previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
return esmOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
return cjsOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function getModuleTransformForFile(file) {
|
|
return file.impliedNodeFormat === 99 /* ESNext */ ? esmTransform : cjsTransform;
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const result = getModuleTransformForFile(node)(node);
|
|
currentSourceFile = void 0;
|
|
Debug.assert(isSourceFile(result));
|
|
return result;
|
|
}
|
|
function transformSourceFileOrBundle(node) {
|
|
return node.kind === 308 /* SourceFile */ ? transformSourceFile(node) : transformBundle(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return context.factory.createBundle(map(node.sourceFiles, transformSourceFile), node.prepends);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/declarations/diagnostics.ts
|
|
function canProduceDiagnostics(node) {
|
|
return isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isBindingElement(node) || isSetAccessor(node) || isGetAccessor(node) || isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isParameter(node) || isTypeParameterDeclaration(node) || isExpressionWithTypeArguments(node) || isImportEqualsDeclaration(node) || isTypeAliasDeclaration(node) || isConstructorDeclaration(node) || isIndexSignatureDeclaration(node) || isPropertyAccessExpression(node) || isJSDocTypeAlias(node);
|
|
}
|
|
function createGetSymbolAccessibilityDiagnosticForNodeName(node) {
|
|
if (isSetAccessor(node) || isGetAccessor(node)) {
|
|
return getAccessorNameVisibilityError;
|
|
} else if (isMethodSignature(node) || isMethodDeclaration(node)) {
|
|
return getMethodNameVisibilityError;
|
|
} else {
|
|
return createGetSymbolAccessibilityDiagnosticForNode(node);
|
|
}
|
|
function getAccessorNameVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
function getMethodNameVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_method_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Method_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
}
|
|
function createGetSymbolAccessibilityDiagnosticForNode(node) {
|
|
if (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isPropertyAccessExpression(node) || isBindingElement(node) || isConstructorDeclaration(node)) {
|
|
return getVariableDeclarationTypeVisibilityError;
|
|
} else if (isSetAccessor(node) || isGetAccessor(node)) {
|
|
return getAccessorDeclarationTypeVisibilityError;
|
|
} else if (isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isIndexSignatureDeclaration(node)) {
|
|
return getReturnTypeVisibilityError;
|
|
} else if (isParameter(node)) {
|
|
if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 8 /* Private */)) {
|
|
return getVariableDeclarationTypeVisibilityError;
|
|
}
|
|
return getParameterDeclarationTypeVisibilityError;
|
|
} else if (isTypeParameterDeclaration(node)) {
|
|
return getTypeParameterConstraintVisibilityError;
|
|
} else if (isExpressionWithTypeArguments(node)) {
|
|
return getHeritageClauseVisibilityError;
|
|
} else if (isImportEqualsDeclaration(node)) {
|
|
return getImportEntityNameVisibilityError;
|
|
} else if (isTypeAliasDeclaration(node) || isJSDocTypeAlias(node)) {
|
|
return getTypeAliasDeclarationVisibilityError;
|
|
} else {
|
|
return Debug.assertNever(node, `Attempted to set a declaration diagnostic context for unhandled node kind: ${Debug.formatSyntaxKind(node.kind)}`);
|
|
}
|
|
function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
|
|
} else if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 208 /* PropertyAccessExpression */ || node.kind === 168 /* PropertySignature */ || node.kind === 166 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */ || node.kind === 166 /* Parameter */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
}
|
|
function getVariableDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
let diagnosticMessage;
|
|
if (node.kind === 175 /* SetAccessor */) {
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
}
|
|
} else {
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? 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 : Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : 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 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node.name,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getReturnTypeVisibilityError(symbolAccessibilityResult) {
|
|
let diagnosticMessage;
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 178 /* IndexSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0;
|
|
} else {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0;
|
|
}
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0;
|
|
break;
|
|
default:
|
|
return Debug.fail("This is unknown kind for signature: " + node.kind);
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node.name || node
|
|
};
|
|
}
|
|
function getParameterDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
switch (node.parent.kind) {
|
|
case 173 /* Constructor */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
|
|
case 177 /* ConstructSignature */:
|
|
case 182 /* ConstructorType */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 176 /* CallSignature */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 178 /* IndexSignature */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node.parent)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 181 /* FunctionType */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_accessor_has_or_is_using_private_name_1;
|
|
default:
|
|
return Debug.fail(`Unknown parent for parameter: ${Debug.formatSyntaxKind(node.parent.kind)}`);
|
|
}
|
|
}
|
|
function getTypeParameterConstraintVisibilityError() {
|
|
let diagnosticMessage;
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;
|
|
break;
|
|
case 261 /* InterfaceDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 197 /* MappedType */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1;
|
|
break;
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node.parent)) {
|
|
diagnosticMessage = 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 /* ClassDeclaration */) {
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
break;
|
|
case 181 /* FunctionType */:
|
|
case 259 /* FunctionDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
|
|
break;
|
|
case 262 /* TypeAliasDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1;
|
|
break;
|
|
default:
|
|
return Debug.fail("This is unknown parent for type parameter: " + node.parent.kind);
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getHeritageClauseVisibilityError() {
|
|
let diagnosticMessage;
|
|
if (isClassDeclaration(node.parent.parent)) {
|
|
diagnosticMessage = isHeritageClause(node.parent) && node.parent.token === 117 /* ImplementsKeyword */ ? Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : node.parent.parent.name ? Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1 : Diagnostics.extends_clause_of_exported_class_has_or_is_using_private_name_0;
|
|
} else {
|
|
diagnosticMessage = Diagnostics.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: getNameOfDeclaration(node.parent.parent)
|
|
};
|
|
}
|
|
function getImportEntityNameVisibilityError() {
|
|
return {
|
|
diagnosticMessage: Diagnostics.Import_declaration_0_is_using_private_name_1,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getTypeAliasDeclarationVisibilityError(symbolAccessibilityResult) {
|
|
return {
|
|
diagnosticMessage: symbolAccessibilityResult.errorModuleName ? Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2 : Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
|
|
errorNode: isJSDocTypeAlias(node) ? Debug.checkDefined(node.typeExpression) : node.type,
|
|
typeName: isJSDocTypeAlias(node) ? getNameOfDeclaration(node) : node.name
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/declarations.ts
|
|
function getDeclarationDiagnostics(host, resolver, file) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const result = transformNodes(resolver, host, factory, compilerOptions, file ? [file] : filter(host.getSourceFiles(), isSourceFileNotJson), [transformDeclarations], false);
|
|
return result.diagnostics;
|
|
}
|
|
function hasInternalAnnotation(range, currentSourceFile) {
|
|
const comment = currentSourceFile.text.substring(range.pos, range.end);
|
|
return stringContains(comment, "@internal");
|
|
}
|
|
function isInternalDeclaration(node, currentSourceFile) {
|
|
const parseTreeNode = getParseTreeNode(node);
|
|
if (parseTreeNode && parseTreeNode.kind === 166 /* Parameter */) {
|
|
const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
|
|
const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
|
|
const text = currentSourceFile.text;
|
|
const commentRanges = previousSibling ? concatenate(
|
|
getTrailingCommentRanges(text, skipTrivia(text, previousSibling.end + 1, false, true)),
|
|
getLeadingCommentRanges(text, node.pos)
|
|
) : getTrailingCommentRanges(text, skipTrivia(text, node.pos, false, true));
|
|
return commentRanges && commentRanges.length && hasInternalAnnotation(last(commentRanges), currentSourceFile);
|
|
}
|
|
const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile);
|
|
return !!forEach(leadingCommentRanges, (range) => {
|
|
return hasInternalAnnotation(range, currentSourceFile);
|
|
});
|
|
}
|
|
var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
|
|
function transformDeclarations(context) {
|
|
const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
|
|
let getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
let needsDeclare = true;
|
|
let isBundledEmit = false;
|
|
let resultHasExternalModuleIndicator = false;
|
|
let needsScopeFixMarker = false;
|
|
let resultHasScopeMarker = false;
|
|
let enclosingDeclaration;
|
|
let necessaryTypeReferences;
|
|
let lateMarkedStatements;
|
|
let lateStatementReplacementMap;
|
|
let suppressNewDiagnosticContexts;
|
|
let exportedModulesFromDeclarationEmit;
|
|
const { factory: factory2 } = context;
|
|
const host = context.getEmitHost();
|
|
const symbolTracker = {
|
|
trackSymbol,
|
|
reportInaccessibleThisError,
|
|
reportInaccessibleUniqueSymbolError,
|
|
reportCyclicStructureError,
|
|
reportPrivateInBaseOfClassExpression,
|
|
reportLikelyUnsafeImportRequiredError,
|
|
reportTruncationError,
|
|
moduleResolverHost: host,
|
|
trackReferencedAmbientModule,
|
|
trackExternalModuleSymbolOfImportTypeNode,
|
|
reportNonlocalAugmentation,
|
|
reportNonSerializableProperty,
|
|
reportImportTypeNodeResolutionModeOverride
|
|
};
|
|
let errorNameNode;
|
|
let errorFallbackNode;
|
|
let currentSourceFile;
|
|
let refs;
|
|
let libs2;
|
|
let emittedImports;
|
|
const resolver = context.getEmitResolver();
|
|
const options = context.getCompilerOptions();
|
|
const { noResolve, stripInternal } = options;
|
|
return transformRoot;
|
|
function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) {
|
|
if (!typeReferenceDirectives) {
|
|
return;
|
|
}
|
|
necessaryTypeReferences = necessaryTypeReferences || /* @__PURE__ */ new Set();
|
|
for (const ref of typeReferenceDirectives) {
|
|
necessaryTypeReferences.add(ref);
|
|
}
|
|
}
|
|
function trackReferencedAmbientModule(node, symbol) {
|
|
const directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, 67108863 /* All */);
|
|
if (length(directives)) {
|
|
return recordTypeReferenceDirectivesIfNecessary(directives);
|
|
}
|
|
const container = getSourceFileOfNode(node);
|
|
refs.set(getOriginalNodeId(container), container);
|
|
}
|
|
function handleSymbolAccessibilityError(symbolAccessibilityResult) {
|
|
if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
|
|
if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
|
|
if (!lateMarkedStatements) {
|
|
lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
|
|
} else {
|
|
for (const ref of symbolAccessibilityResult.aliasesToMakeVisible) {
|
|
pushIfUnique(lateMarkedStatements, ref);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
|
|
if (errorInfo) {
|
|
if (errorInfo.typeName) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
symbolAccessibilityResult.errorNode || errorInfo.errorNode,
|
|
errorInfo.diagnosticMessage,
|
|
getTextOfNode(errorInfo.typeName),
|
|
symbolAccessibilityResult.errorSymbolName,
|
|
symbolAccessibilityResult.errorModuleName
|
|
));
|
|
} else {
|
|
context.addDiagnostic(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, enclosingDeclaration2, meaning) {
|
|
if (symbol.flags & 262144 /* TypeParameter */)
|
|
return false;
|
|
const issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration2, meaning, true));
|
|
recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
|
|
return issuedDiagnostic;
|
|
}
|
|
function reportPrivateInBaseOfClassExpression(propertyName) {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(
|
|
createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)
|
|
);
|
|
}
|
|
}
|
|
function errorDeclarationNameWithFallback() {
|
|
return errorNameNode ? declarationNameToString(errorNameNode) : errorFallbackNode && getNameOfDeclaration(errorFallbackNode) ? declarationNameToString(getNameOfDeclaration(errorFallbackNode)) : errorFallbackNode && isExportAssignment(errorFallbackNode) ? errorFallbackNode.isExportEquals ? "export=" : "default" : "(Missing)";
|
|
}
|
|
function reportInaccessibleUniqueSymbolError() {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
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(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
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(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
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(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
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(createDiagnosticForNode(errorNameNode || errorFallbackNode, 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 _a2;
|
|
const primaryDeclaration = (_a2 = parentSymbol.declarations) == null ? void 0 : _a2.find((d) => getSourceFileOfNode(d) === containingFile);
|
|
const augmentingDeclarations = filter(symbol.declarations, (d) => getSourceFileOfNode(d) !== containingFile);
|
|
if (primaryDeclaration && augmentingDeclarations) {
|
|
for (const augmentations of augmentingDeclarations) {
|
|
context.addDiagnostic(addRelatedInfo(
|
|
createDiagnosticForNode(augmentations, Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized),
|
|
createDiagnosticForNode(primaryDeclaration, Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function reportNonSerializableProperty(propertyName) {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));
|
|
}
|
|
}
|
|
function reportImportTypeNodeResolutionModeOverride() {
|
|
if (!isNightly() && (errorNameNode || errorFallbackNode)) {
|
|
context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, 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) {
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = (s) => s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : {
|
|
diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
|
|
errorNode: s.errorNode || sourceFile
|
|
};
|
|
const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
return result;
|
|
}
|
|
function transformRoot(node) {
|
|
if (node.kind === 308 /* SourceFile */ && node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
if (node.kind === 309 /* Bundle */) {
|
|
isBundledEmit = true;
|
|
refs = /* @__PURE__ */ new Map();
|
|
libs2 = /* @__PURE__ */ new Map();
|
|
let hasNoDefaultLib = false;
|
|
const bundle = factory2.createBundle(map(
|
|
node.sourceFiles,
|
|
(sourceFile) => {
|
|
if (sourceFile.isDeclarationFile)
|
|
return void 0;
|
|
hasNoDefaultLib = hasNoDefaultLib || sourceFile.hasNoDefaultLib;
|
|
currentSourceFile = sourceFile;
|
|
enclosingDeclaration = sourceFile;
|
|
lateMarkedStatements = void 0;
|
|
suppressNewDiagnosticContexts = false;
|
|
lateStatementReplacementMap = /* @__PURE__ */ new Map();
|
|
getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
needsScopeFixMarker = false;
|
|
resultHasScopeMarker = false;
|
|
collectReferences(sourceFile, refs);
|
|
collectLibs(sourceFile, libs2);
|
|
if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
|
|
resultHasExternalModuleIndicator = false;
|
|
needsDeclare = false;
|
|
const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile, true)) : visitNodes2(sourceFile.statements, visitDeclarationStatements);
|
|
const newFile = factory2.updateSourceFile(sourceFile, [factory2.createModuleDeclaration(
|
|
[factory2.createModifier(136 /* DeclareKeyword */)],
|
|
factory2.createStringLiteral(getResolvedExternalModuleName(context.getEmitHost(), sourceFile)),
|
|
factory2.createModuleBlock(setTextRange(factory2.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements))
|
|
)], true, [], [], false, []);
|
|
return newFile;
|
|
}
|
|
needsDeclare = true;
|
|
const updated2 = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements);
|
|
return factory2.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated2), true, [], [], false, []);
|
|
}
|
|
), mapDefined(node.prepends, (prepend) => {
|
|
if (prepend.kind === 311 /* InputFiles */) {
|
|
const sourceFile = createUnparsedSourceFile(prepend, "dts", stripInternal);
|
|
hasNoDefaultLib = hasNoDefaultLib || !!sourceFile.hasNoDefaultLib;
|
|
collectReferences(sourceFile, refs);
|
|
recordTypeReferenceDirectivesIfNecessary(map(sourceFile.typeReferenceDirectives, (ref) => [ref.fileName, ref.resolutionMode]));
|
|
collectLibs(sourceFile, libs2);
|
|
return sourceFile;
|
|
}
|
|
return prepend;
|
|
}));
|
|
bundle.syntheticFileReferences = [];
|
|
bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences();
|
|
bundle.syntheticLibReferences = getLibReferences();
|
|
bundle.hasNoDefaultLib = hasNoDefaultLib;
|
|
const outputFilePath2 = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, true).declarationFilePath));
|
|
const referenceVisitor2 = mapReferencesIntoArray(bundle.syntheticFileReferences, outputFilePath2);
|
|
refs.forEach(referenceVisitor2);
|
|
return bundle;
|
|
}
|
|
needsDeclare = true;
|
|
needsScopeFixMarker = false;
|
|
resultHasScopeMarker = false;
|
|
enclosingDeclaration = node;
|
|
currentSourceFile = node;
|
|
getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
isBundledEmit = false;
|
|
resultHasExternalModuleIndicator = false;
|
|
suppressNewDiagnosticContexts = false;
|
|
lateMarkedStatements = void 0;
|
|
lateStatementReplacementMap = /* @__PURE__ */ new Map();
|
|
necessaryTypeReferences = void 0;
|
|
refs = collectReferences(currentSourceFile, /* @__PURE__ */ new Map());
|
|
libs2 = collectLibs(currentSourceFile, /* @__PURE__ */ new Map());
|
|
const references = [];
|
|
const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, true).declarationFilePath));
|
|
const referenceVisitor = mapReferencesIntoArray(references, outputFilePath);
|
|
let combinedStatements;
|
|
if (isSourceFileJS(currentSourceFile)) {
|
|
combinedStatements = factory2.createNodeArray(transformDeclarationsForJS(node));
|
|
refs.forEach(referenceVisitor);
|
|
emittedImports = filter(combinedStatements, isAnyImportSyntax);
|
|
} else {
|
|
const statements = visitNodes2(node.statements, visitDeclarationStatements);
|
|
combinedStatements = setTextRange(factory2.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
|
|
refs.forEach(referenceVisitor);
|
|
emittedImports = filter(combinedStatements, isAnyImportSyntax);
|
|
if (isExternalModule(node) && (!resultHasExternalModuleIndicator || needsScopeFixMarker && !resultHasScopeMarker)) {
|
|
combinedStatements = setTextRange(factory2.createNodeArray([...combinedStatements, createEmptyExports(factory2)]), combinedStatements);
|
|
}
|
|
}
|
|
const updated = factory2.updateSourceFile(node, combinedStatements, true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences());
|
|
updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;
|
|
return updated;
|
|
function getLibReferences() {
|
|
return map(arrayFrom(libs2.keys()), (lib) => ({ fileName: lib, pos: -1, end: -1 }));
|
|
}
|
|
function getFileReferencesForUsedTypeReferences() {
|
|
return necessaryTypeReferences ? mapDefined(arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForSpecifierModeTuple) : [];
|
|
}
|
|
function getFileReferenceForSpecifierModeTuple([typeName, mode]) {
|
|
if (emittedImports) {
|
|
for (const importStatement of emittedImports) {
|
|
if (isImportEqualsDeclaration(importStatement) && isExternalModuleReference(importStatement.moduleReference)) {
|
|
const expr = importStatement.moduleReference.expression;
|
|
if (isStringLiteralLike(expr) && expr.text === typeName) {
|
|
return void 0;
|
|
}
|
|
} else if (isImportDeclaration(importStatement) && isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return { fileName: typeName, pos: -1, end: -1, ...mode ? { resolutionMode: mode } : void 0 };
|
|
}
|
|
function mapReferencesIntoArray(references2, outputFilePath2) {
|
|
return (file) => {
|
|
let declFileName;
|
|
if (file.isDeclarationFile) {
|
|
declFileName = file.fileName;
|
|
} else {
|
|
if (isBundledEmit && contains(node.sourceFiles, file))
|
|
return;
|
|
const paths = getOutputPathsFor(file, host, true);
|
|
declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName;
|
|
}
|
|
if (declFileName) {
|
|
const specifier = getModuleSpecifier(
|
|
options,
|
|
currentSourceFile,
|
|
toPath(outputFilePath2, host.getCurrentDirectory(), host.getCanonicalFileName),
|
|
toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName),
|
|
host
|
|
);
|
|
if (!pathIsRelative(specifier)) {
|
|
recordTypeReferenceDirectivesIfNecessary([[specifier, void 0]]);
|
|
return;
|
|
}
|
|
let fileName = getRelativePathToDirectoryOrUrl(
|
|
outputFilePath2,
|
|
declFileName,
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
false
|
|
);
|
|
if (startsWith(fileName, "./") && hasExtension(fileName)) {
|
|
fileName = fileName.substring(2);
|
|
}
|
|
if (startsWith(fileName, "node_modules/") || pathContainsNodeModules(fileName)) {
|
|
return;
|
|
}
|
|
references2.push({ pos: -1, end: -1, fileName });
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function collectReferences(sourceFile, ret) {
|
|
if (noResolve || !isUnparsedSource(sourceFile) && isSourceFileJS(sourceFile))
|
|
return ret;
|
|
forEach(sourceFile.referencedFiles, (f) => {
|
|
const elem = host.getSourceFileFromReference(sourceFile, f);
|
|
if (elem) {
|
|
ret.set(getOriginalNodeId(elem), elem);
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function collectLibs(sourceFile, ret) {
|
|
forEach(sourceFile.libReferenceDirectives, (ref) => {
|
|
const lib = host.getLibFileFromReference(ref);
|
|
if (lib) {
|
|
ret.set(toFileNameLowerCase(ref.fileName), true);
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function filterBindingPatternInitializersAndRenamings(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
return name;
|
|
} else {
|
|
if (name.kind === 204 /* ArrayBindingPattern */) {
|
|
return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement));
|
|
} else {
|
|
return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement));
|
|
}
|
|
}
|
|
function visitBindingElement(elem) {
|
|
if (elem.kind === 229 /* OmittedExpression */) {
|
|
return elem;
|
|
}
|
|
if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced) {
|
|
return factory2.updateBindingElement(
|
|
elem,
|
|
elem.dotDotDotToken,
|
|
void 0,
|
|
elem.propertyName,
|
|
shouldPrintWithInitializer(elem) ? elem.initializer : void 0
|
|
);
|
|
}
|
|
return factory2.updateBindingElement(
|
|
elem,
|
|
elem.dotDotDotToken,
|
|
elem.propertyName,
|
|
filterBindingPatternInitializersAndRenamings(elem.name),
|
|
shouldPrintWithInitializer(elem) ? elem.initializer : void 0
|
|
);
|
|
}
|
|
}
|
|
function ensureParameter(p, modifierMask, type) {
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p);
|
|
}
|
|
const newParam = factory2.updateParameterDeclaration(
|
|
p,
|
|
maskModifiers(p, modifierMask),
|
|
p.dotDotDotToken,
|
|
filterBindingPatternInitializersAndRenamings(p.name),
|
|
resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(57 /* QuestionToken */) : void 0,
|
|
ensureType(p, type || p.type, true),
|
|
ensureNoInitializer(p)
|
|
);
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
return newParam;
|
|
}
|
|
function shouldPrintWithInitializer(node) {
|
|
return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(getParseTreeNode(node));
|
|
}
|
|
function ensureNoInitializer(node) {
|
|
if (shouldPrintWithInitializer(node)) {
|
|
return resolver.createLiteralConstValue(getParseTreeNode(node), symbolTracker);
|
|
}
|
|
return void 0;
|
|
}
|
|
function ensureType(node, type, ignorePrivate) {
|
|
if (!ignorePrivate && hasEffectiveModifier(node, 8 /* Private */)) {
|
|
return;
|
|
}
|
|
if (shouldPrintWithInitializer(node)) {
|
|
return;
|
|
}
|
|
const shouldUseResolverType = node.kind === 166 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
|
|
if (type && !shouldUseResolverType) {
|
|
return visitNode(type, visitDeclarationSubtree);
|
|
}
|
|
if (!getParseTreeNode(node)) {
|
|
return type ? visitNode(type, visitDeclarationSubtree) : factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (node.kind === 175 /* SetAccessor */) {
|
|
return factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
errorNameNode = node.name;
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
|
|
}
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
|
|
}
|
|
if (node.kind === 166 /* Parameter */ || node.kind === 169 /* PropertyDeclaration */ || node.kind === 168 /* PropertySignature */) {
|
|
if (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 = void 0;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
return returnValue || factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
}
|
|
function isDeclarationAndNotVisible(node) {
|
|
node = getParseTreeNode(node);
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return !resolver.isDeclarationVisible(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return !getBindingNameVisible(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
return false;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function shouldEmitFunctionProperties(input) {
|
|
var _a2;
|
|
if (input.body) {
|
|
return true;
|
|
}
|
|
const overloadSignatures = (_a2 = input.symbol.declarations) == null ? void 0 : _a2.filter((decl) => isFunctionDeclaration(decl) && !decl.body);
|
|
return !overloadSignatures || overloadSignatures.indexOf(input) === overloadSignatures.length - 1;
|
|
}
|
|
function getBindingNameVisible(elem) {
|
|
if (isOmittedExpression(elem)) {
|
|
return false;
|
|
}
|
|
if (isBindingPattern(elem.name)) {
|
|
return some(elem.name.elements, getBindingNameVisible);
|
|
} else {
|
|
return resolver.isDeclarationVisible(elem);
|
|
}
|
|
}
|
|
function updateParamsList(node, params, modifierMask) {
|
|
if (hasEffectiveModifier(node, 8 /* Private */)) {
|
|
return void 0;
|
|
}
|
|
const newParams = map(params, (p) => ensureParameter(p, modifierMask));
|
|
if (!newParams) {
|
|
return void 0;
|
|
}
|
|
return factory2.createNodeArray(newParams, params.hasTrailingComma);
|
|
}
|
|
function updateAccessorParamsList(input, isPrivate) {
|
|
let newParams;
|
|
if (!isPrivate) {
|
|
const thisParameter = getThisParameter(input);
|
|
if (thisParameter) {
|
|
newParams = [ensureParameter(thisParameter)];
|
|
}
|
|
}
|
|
if (isSetAccessorDeclaration(input)) {
|
|
let newValueParameter;
|
|
if (!isPrivate) {
|
|
const valueParameter = getSetAccessorValueParameter(input);
|
|
if (valueParameter) {
|
|
const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
|
|
newValueParameter = ensureParameter(valueParameter, void 0, accessorType);
|
|
}
|
|
}
|
|
if (!newValueParameter) {
|
|
newValueParameter = factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"value"
|
|
);
|
|
}
|
|
newParams = append(newParams, newValueParameter);
|
|
}
|
|
return factory2.createNodeArray(newParams || emptyArray);
|
|
}
|
|
function ensureTypeParams(node, params) {
|
|
return hasEffectiveModifier(node, 8 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree);
|
|
}
|
|
function isEnclosingDeclaration(node) {
|
|
return isSourceFile(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionLike(node) || isIndexSignatureDeclaration(node) || isMappedTypeNode(node);
|
|
}
|
|
function checkEntityNameVisibility(entityName, enclosingDeclaration2) {
|
|
const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration2);
|
|
handleSymbolAccessibilityError(visibilityResult);
|
|
recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));
|
|
}
|
|
function preserveJsDoc(updated, original) {
|
|
if (hasJSDocNodes(updated) && hasJSDocNodes(original)) {
|
|
updated.jsDoc = original.jsDoc;
|
|
}
|
|
return setCommentRange(updated, getCommentRange(original));
|
|
}
|
|
function rewriteModuleSpecifier(parent, input) {
|
|
if (!input)
|
|
return void 0;
|
|
resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent.kind !== 264 /* ModuleDeclaration */ && parent.kind !== 202 /* ImportType */;
|
|
if (isStringLiteralLike(input)) {
|
|
if (isBundledEmit) {
|
|
const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent);
|
|
if (newName) {
|
|
return factory2.createStringLiteral(newName);
|
|
}
|
|
} else {
|
|
const 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 /* ExternalModuleReference */) {
|
|
const specifier = getExternalModuleImportEqualsDeclarationExpression(decl);
|
|
return factory2.updateImportEqualsDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
decl.isTypeOnly,
|
|
decl.name,
|
|
factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))
|
|
);
|
|
} else {
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(decl);
|
|
checkEntityNameVisibility(decl.moduleReference, enclosingDeclaration);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
return decl;
|
|
}
|
|
}
|
|
function transformImportDeclaration(decl) {
|
|
if (!decl.importClause) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
decl.importClause,
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
const visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : void 0;
|
|
if (!decl.importClause.namedBindings) {
|
|
return visibleDefaultBinding && factory2.updateImportDeclaration(decl, decl.modifiers, factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
void 0
|
|
), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
|
|
}
|
|
if (decl.importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
const namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : void 0;
|
|
return visibleDefaultBinding || namedBindings ? factory2.updateImportDeclaration(decl, decl.modifiers, factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
namedBindings
|
|
), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)) : void 0;
|
|
}
|
|
const bindingList = mapDefined(decl.importClause.namedBindings.elements, (b) => resolver.isDeclarationVisible(b) ? b : void 0);
|
|
if (bindingList && bindingList.length || visibleDefaultBinding) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
bindingList && bindingList.length ? factory2.updateNamedImports(decl.importClause.namedBindings, bindingList) : void 0
|
|
),
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
if (resolver.isImportRequiredByAugmentation(decl)) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
void 0,
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
}
|
|
function getResolutionModeOverrideForClauseInNightly(assertClause) {
|
|
const mode = getResolutionModeOverrideForClause(assertClause);
|
|
if (mode !== void 0) {
|
|
if (!isNightly()) {
|
|
context.addDiagnostic(createDiagnosticForNode(assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
|
|
}
|
|
return assertClause;
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformAndReplaceLatePaintedStatements(statements) {
|
|
while (length(lateMarkedStatements)) {
|
|
const i = lateMarkedStatements.shift();
|
|
if (!isLateVisibilityPaintedStatement(i)) {
|
|
return Debug.fail(`Late replaced statement was found which is not handled by the declaration transformer!: ${Debug.formatSyntaxKind(i.kind)}`);
|
|
}
|
|
const priorNeedsDeclare = needsDeclare;
|
|
needsDeclare = i.parent && isSourceFile(i.parent) && !(isExternalModule(i.parent) && isBundledEmit);
|
|
const result = transformTopLevelDeclaration(i);
|
|
needsDeclare = priorNeedsDeclare;
|
|
lateStatementReplacementMap.set(getOriginalNodeId(i), result);
|
|
}
|
|
return visitNodes2(statements, visitLateVisibilityMarkedStatements);
|
|
function visitLateVisibilityMarkedStatements(statement) {
|
|
if (isLateVisibilityPaintedStatement(statement)) {
|
|
const key = getOriginalNodeId(statement);
|
|
if (lateStatementReplacementMap.has(key)) {
|
|
const result = lateStatementReplacementMap.get(key);
|
|
lateStatementReplacementMap.delete(key);
|
|
if (result) {
|
|
if (isArray(result) ? some(result, needsScopeMarker) : needsScopeMarker(result)) {
|
|
needsScopeFixMarker = true;
|
|
}
|
|
if (isSourceFile(statement.parent) && (isArray(result) ? some(result, isExternalModuleIndicator) : isExternalModuleIndicator(result))) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
return statement;
|
|
}
|
|
}
|
|
function visitDeclarationSubtree(input) {
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
if (isDeclaration(input)) {
|
|
if (isDeclarationAndNotVisible(input))
|
|
return;
|
|
if (hasDynamicName(input) && !resolver.isLateBound(getParseTreeNode(input))) {
|
|
return;
|
|
}
|
|
}
|
|
if (isFunctionLike(input) && resolver.isImplementationOfOverload(input))
|
|
return;
|
|
if (isSemicolonClassElement(input))
|
|
return;
|
|
let previousEnclosingDeclaration;
|
|
if (isEnclosingDeclaration(input)) {
|
|
previousEnclosingDeclaration = enclosingDeclaration;
|
|
enclosingDeclaration = input;
|
|
}
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
const canProduceDiagnostic = canProduceDiagnostics(input);
|
|
const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
|
|
let shouldEnterSuppressNewDiagnosticsContextContext = (input.kind === 184 /* TypeLiteral */ || input.kind === 197 /* MappedType */) && input.parent.kind !== 262 /* TypeAliasDeclaration */;
|
|
if (isMethodDeclaration(input) || isMethodSignature(input)) {
|
|
if (hasEffectiveModifier(input, 8 /* Private */)) {
|
|
if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input)
|
|
return;
|
|
return cleanup(factory2.createPropertyDeclaration(ensureModifiers(input), input.name, void 0, void 0, void 0));
|
|
}
|
|
}
|
|
if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(input);
|
|
}
|
|
if (isTypeQueryNode(input)) {
|
|
checkEntityNameVisibility(input.exprName, enclosingDeclaration);
|
|
}
|
|
if (shouldEnterSuppressNewDiagnosticsContextContext) {
|
|
suppressNewDiagnosticContexts = true;
|
|
}
|
|
if (isProcessedComponent(input)) {
|
|
switch (input.kind) {
|
|
case 230 /* ExpressionWithTypeArguments */: {
|
|
if (isEntityName(input.expression) || isEntityNameExpression(input.expression)) {
|
|
checkEntityNameVisibility(input.expression, enclosingDeclaration);
|
|
}
|
|
const node = visitEachChild(input, visitDeclarationSubtree, context);
|
|
return cleanup(factory2.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments));
|
|
}
|
|
case 180 /* TypeReference */: {
|
|
checkEntityNameVisibility(input.typeName, enclosingDeclaration);
|
|
const node = visitEachChild(input, visitDeclarationSubtree, context);
|
|
return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
|
|
}
|
|
case 177 /* ConstructSignature */:
|
|
return cleanup(factory2.updateConstructSignature(
|
|
input,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
case 173 /* Constructor */: {
|
|
const ctor = factory2.createConstructorDeclaration(
|
|
ensureModifiers(input),
|
|
updateParamsList(input, input.parameters, 0 /* None */),
|
|
void 0
|
|
);
|
|
return cleanup(ctor);
|
|
}
|
|
case 171 /* MethodDeclaration */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
const sig = factory2.createMethodDeclaration(
|
|
ensureModifiers(input),
|
|
void 0,
|
|
input.name,
|
|
input.questionToken,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type),
|
|
void 0
|
|
);
|
|
return cleanup(sig);
|
|
}
|
|
case 174 /* GetAccessor */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
|
|
return cleanup(factory2.updateGetAccessorDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
|
|
ensureType(input, accessorType),
|
|
void 0
|
|
));
|
|
}
|
|
case 175 /* SetAccessor */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updateSetAccessorDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
|
|
void 0
|
|
));
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updatePropertyDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureType(input, input.type),
|
|
ensureNoInitializer(input)
|
|
));
|
|
case 168 /* PropertySignature */:
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updatePropertySignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureType(input, input.type)
|
|
));
|
|
case 170 /* MethodSignature */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updateMethodSignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
}
|
|
case 176 /* CallSignature */: {
|
|
return cleanup(factory2.updateCallSignature(
|
|
input,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
}
|
|
case 178 /* IndexSignature */: {
|
|
return cleanup(factory2.updateIndexSignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
updateParamsList(input, input.parameters),
|
|
visitNode(input.type, visitDeclarationSubtree) || factory2.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
));
|
|
}
|
|
case 257 /* VariableDeclaration */: {
|
|
if (isBindingPattern(input.name)) {
|
|
return recreateBindingPattern(input.name);
|
|
}
|
|
shouldEnterSuppressNewDiagnosticsContextContext = true;
|
|
suppressNewDiagnosticContexts = true;
|
|
return cleanup(factory2.updateVariableDeclaration(input, input.name, void 0, ensureType(input, input.type), ensureNoInitializer(input)));
|
|
}
|
|
case 165 /* TypeParameter */: {
|
|
if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) {
|
|
return cleanup(factory2.updateTypeParameterDeclaration(input, input.modifiers, input.name, void 0, void 0));
|
|
}
|
|
return cleanup(visitEachChild(input, visitDeclarationSubtree, context));
|
|
}
|
|
case 191 /* ConditionalType */: {
|
|
const checkType = visitNode(input.checkType, visitDeclarationSubtree);
|
|
const extendsType = visitNode(input.extendsType, visitDeclarationSubtree);
|
|
const oldEnclosingDecl = enclosingDeclaration;
|
|
enclosingDeclaration = input.trueType;
|
|
const trueType = visitNode(input.trueType, visitDeclarationSubtree);
|
|
enclosingDeclaration = oldEnclosingDecl;
|
|
const falseType = visitNode(input.falseType, visitDeclarationSubtree);
|
|
return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
|
|
}
|
|
case 181 /* FunctionType */: {
|
|
return cleanup(factory2.updateFunctionTypeNode(input, visitNodes2(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), visitNode(input.type, visitDeclarationSubtree)));
|
|
}
|
|
case 182 /* ConstructorType */: {
|
|
return cleanup(factory2.updateConstructorTypeNode(input, ensureModifiers(input), visitNodes2(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), visitNode(input.type, visitDeclarationSubtree)));
|
|
}
|
|
case 202 /* ImportType */: {
|
|
if (!isLiteralImportTypeNode(input))
|
|
return cleanup(input);
|
|
return cleanup(factory2.updateImportTypeNode(
|
|
input,
|
|
factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)),
|
|
input.assertions,
|
|
input.qualifier,
|
|
visitNodes2(input.typeArguments, visitDeclarationSubtree, isTypeNode),
|
|
input.isTypeOf
|
|
));
|
|
}
|
|
default:
|
|
Debug.assertNever(input, `Attempted to process unhandled node kind: ${Debug.formatSyntaxKind(input.kind)}`);
|
|
}
|
|
}
|
|
if (isTupleTypeNode(input) && getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === getLineAndCharacterOfPosition(currentSourceFile, input.end).line) {
|
|
setEmitFlags(input, 1 /* SingleLine */);
|
|
}
|
|
return cleanup(visitEachChild(input, visitDeclarationSubtree, context));
|
|
function cleanup(returnValue) {
|
|
if (returnValue && canProduceDiagnostic && 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 && setOriginalNode(preserveJsDoc(returnValue, input), input);
|
|
}
|
|
}
|
|
function isPrivateMethodTypeParameter(node) {
|
|
return node.parent.kind === 171 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 8 /* Private */);
|
|
}
|
|
function visitDeclarationStatements(input) {
|
|
if (!isPreservedDeclarationStatement(input)) {
|
|
return;
|
|
}
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
switch (input.kind) {
|
|
case 275 /* ExportDeclaration */: {
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
return factory2.updateExportDeclaration(
|
|
input,
|
|
input.modifiers,
|
|
input.isTypeOnly,
|
|
input.exportClause,
|
|
rewriteModuleSpecifier(input, input.moduleSpecifier),
|
|
getResolutionModeOverrideForClause(input.assertClause) ? input.assertClause : void 0
|
|
);
|
|
}
|
|
case 274 /* ExportAssignment */: {
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
if (input.expression.kind === 79 /* Identifier */) {
|
|
return input;
|
|
} else {
|
|
const newId = factory2.createUniqueName("_default", 16 /* Optimistic */);
|
|
getSymbolAccessibilityDiagnostic = () => ({
|
|
diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
|
|
errorNode: input
|
|
});
|
|
errorFallbackNode = input;
|
|
const varDecl = factory2.createVariableDeclaration(newId, void 0, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), void 0);
|
|
errorFallbackNode = void 0;
|
|
const statement = factory2.createVariableStatement(needsDeclare ? [factory2.createModifier(136 /* DeclareKeyword */)] : [], factory2.createVariableDeclarationList([varDecl], 2 /* Const */));
|
|
preserveJsDoc(statement, input);
|
|
removeAllComments(input);
|
|
return [statement, factory2.updateExportAssignment(input, input.modifiers, newId)];
|
|
}
|
|
}
|
|
}
|
|
const result = transformTopLevelDeclaration(input);
|
|
lateStatementReplacementMap.set(getOriginalNodeId(input), result);
|
|
return input;
|
|
}
|
|
function stripExportModifiers(statement) {
|
|
if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 1024 /* Default */) || !canHaveModifiers(statement)) {
|
|
return statement;
|
|
}
|
|
const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (258047 /* All */ ^ 1 /* Export */));
|
|
return factory2.updateModifiers(statement, modifiers);
|
|
}
|
|
function transformTopLevelDeclaration(input) {
|
|
if (lateMarkedStatements) {
|
|
while (orderedRemoveItem(lateMarkedStatements, input))
|
|
;
|
|
}
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
switch (input.kind) {
|
|
case 268 /* ImportEqualsDeclaration */: {
|
|
return transformImportEqualsDeclaration(input);
|
|
}
|
|
case 269 /* ImportDeclaration */: {
|
|
return transformImportDeclaration(input);
|
|
}
|
|
}
|
|
if (isDeclaration(input) && isDeclarationAndNotVisible(input))
|
|
return;
|
|
if (isFunctionLike(input) && resolver.isImplementationOfOverload(input))
|
|
return;
|
|
let previousEnclosingDeclaration;
|
|
if (isEnclosingDeclaration(input)) {
|
|
previousEnclosingDeclaration = enclosingDeclaration;
|
|
enclosingDeclaration = input;
|
|
}
|
|
const canProdiceDiagnostic = canProduceDiagnostics(input);
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
if (canProdiceDiagnostic) {
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(input);
|
|
}
|
|
const previousNeedsDeclare = needsDeclare;
|
|
switch (input.kind) {
|
|
case 262 /* TypeAliasDeclaration */: {
|
|
needsDeclare = false;
|
|
const clean2 = cleanup(factory2.updateTypeAliasDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
|
|
visitNode(input.type, visitDeclarationSubtree, isTypeNode)
|
|
));
|
|
needsDeclare = previousNeedsDeclare;
|
|
return clean2;
|
|
}
|
|
case 261 /* InterfaceDeclaration */: {
|
|
return cleanup(factory2.updateInterfaceDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
transformHeritageClauses(input.heritageClauses),
|
|
visitNodes2(input.members, visitDeclarationSubtree)
|
|
));
|
|
}
|
|
case 259 /* FunctionDeclaration */: {
|
|
const clean2 = cleanup(factory2.updateFunctionDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
void 0,
|
|
input.name,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type),
|
|
void 0
|
|
));
|
|
if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
|
|
const props = resolver.getPropertiesOfContainerFunction(input);
|
|
const fakespace = parseNodeFactory.createModuleDeclaration(void 0, clean2.name || factory2.createIdentifier("_default"), factory2.createModuleBlock([]), 16 /* Namespace */);
|
|
setParent(fakespace, enclosingDeclaration);
|
|
fakespace.locals = createSymbolTable(props);
|
|
fakespace.symbol = props[0].parent;
|
|
const exportMappings = [];
|
|
let declarations = mapDefined(props, (p) => {
|
|
if (!p.valueDeclaration || !isPropertyAccessExpression(p.valueDeclaration)) {
|
|
return void 0;
|
|
}
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
|
|
const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, symbolTracker);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
const nameStr = unescapeLeadingUnderscores(p.escapedName);
|
|
const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
|
|
const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
|
|
if (isNonContextualKeywordName) {
|
|
exportMappings.push([name, nameStr]);
|
|
}
|
|
const varDecl = factory2.createVariableDeclaration(name, void 0, type, void 0);
|
|
return factory2.createVariableStatement(isNonContextualKeywordName ? void 0 : [factory2.createToken(93 /* ExportKeyword */)], factory2.createVariableDeclarationList([varDecl]));
|
|
});
|
|
if (!exportMappings.length) {
|
|
declarations = mapDefined(declarations, (declaration) => factory2.updateModifiers(declaration, 0 /* None */));
|
|
} else {
|
|
declarations.push(factory2.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory2.createNamedExports(map(exportMappings, ([gen, exp]) => {
|
|
return factory2.createExportSpecifier(false, gen, exp);
|
|
}))
|
|
));
|
|
}
|
|
const namespaceDecl = factory2.createModuleDeclaration(ensureModifiers(input), input.name, factory2.createModuleBlock(declarations), 16 /* Namespace */);
|
|
if (!hasEffectiveModifier(clean2, 1024 /* Default */)) {
|
|
return [clean2, namespaceDecl];
|
|
}
|
|
const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~1025 /* ExportDefault */ | 2 /* Ambient */);
|
|
const cleanDeclaration = factory2.updateFunctionDeclaration(
|
|
clean2,
|
|
modifiers,
|
|
void 0,
|
|
clean2.name,
|
|
clean2.typeParameters,
|
|
clean2.parameters,
|
|
clean2.type,
|
|
void 0
|
|
);
|
|
const namespaceDeclaration = factory2.updateModuleDeclaration(
|
|
namespaceDecl,
|
|
modifiers,
|
|
namespaceDecl.name,
|
|
namespaceDecl.body
|
|
);
|
|
const exportDefaultDeclaration = factory2.createExportAssignment(
|
|
void 0,
|
|
false,
|
|
namespaceDecl.name
|
|
);
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
return [cleanDeclaration, namespaceDeclaration, exportDefaultDeclaration];
|
|
} else {
|
|
return clean2;
|
|
}
|
|
}
|
|
case 264 /* ModuleDeclaration */: {
|
|
needsDeclare = false;
|
|
const inner = input.body;
|
|
if (inner && inner.kind === 265 /* ModuleBlock */) {
|
|
const oldNeedsScopeFix = needsScopeFixMarker;
|
|
const oldHasScopeFix = resultHasScopeMarker;
|
|
resultHasScopeMarker = false;
|
|
needsScopeFixMarker = false;
|
|
const statements = visitNodes2(inner.statements, visitDeclarationStatements);
|
|
let lateStatements = transformAndReplaceLatePaintedStatements(statements);
|
|
if (input.flags & 16777216 /* Ambient */) {
|
|
needsScopeFixMarker = false;
|
|
}
|
|
if (!isGlobalScopeAugmentation(input) && !hasScopeMarker2(lateStatements) && !resultHasScopeMarker) {
|
|
if (needsScopeFixMarker) {
|
|
lateStatements = factory2.createNodeArray([...lateStatements, createEmptyExports(factory2)]);
|
|
} else {
|
|
lateStatements = visitNodes2(lateStatements, stripExportModifiers);
|
|
}
|
|
}
|
|
const body = factory2.updateModuleBlock(inner, lateStatements);
|
|
needsDeclare = previousNeedsDeclare;
|
|
needsScopeFixMarker = oldNeedsScopeFix;
|
|
resultHasScopeMarker = oldHasScopeFix;
|
|
const mods = ensureModifiers(input);
|
|
return cleanup(factory2.updateModuleDeclaration(
|
|
input,
|
|
mods,
|
|
isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name,
|
|
body
|
|
));
|
|
} else {
|
|
needsDeclare = previousNeedsDeclare;
|
|
const mods = ensureModifiers(input);
|
|
needsDeclare = false;
|
|
visitNode(inner, visitDeclarationStatements);
|
|
const id = getOriginalNodeId(inner);
|
|
const body = lateStatementReplacementMap.get(id);
|
|
lateStatementReplacementMap.delete(id);
|
|
return cleanup(factory2.updateModuleDeclaration(
|
|
input,
|
|
mods,
|
|
input.name,
|
|
body
|
|
));
|
|
}
|
|
}
|
|
case 260 /* ClassDeclaration */: {
|
|
errorNameNode = input.name;
|
|
errorFallbackNode = input;
|
|
const modifiers = factory2.createNodeArray(ensureModifiers(input));
|
|
const typeParameters = ensureTypeParams(input, input.typeParameters);
|
|
const ctor = getFirstConstructorWithBody(input);
|
|
let parameterProperties;
|
|
if (ctor) {
|
|
const oldDiag2 = getSymbolAccessibilityDiagnostic;
|
|
parameterProperties = compact(flatMap(ctor.parameters, (param) => {
|
|
if (!hasSyntacticModifier(param, 16476 /* ParameterPropertyModifier */) || shouldStripInternal(param))
|
|
return;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(param);
|
|
if (param.name.kind === 79 /* Identifier */) {
|
|
return preserveJsDoc(factory2.createPropertyDeclaration(
|
|
ensureModifiers(param),
|
|
param.name,
|
|
param.questionToken,
|
|
ensureType(param, param.type),
|
|
ensureNoInitializer(param)
|
|
), param);
|
|
} else {
|
|
return walkBindingPattern(param.name);
|
|
}
|
|
function walkBindingPattern(pattern) {
|
|
let elems;
|
|
for (const elem of pattern.elements) {
|
|
if (isOmittedExpression(elem))
|
|
continue;
|
|
if (isBindingPattern(elem.name)) {
|
|
elems = concatenate(elems, walkBindingPattern(elem.name));
|
|
}
|
|
elems = elems || [];
|
|
elems.push(factory2.createPropertyDeclaration(
|
|
ensureModifiers(param),
|
|
elem.name,
|
|
void 0,
|
|
ensureType(elem, void 0),
|
|
void 0
|
|
));
|
|
}
|
|
return elems;
|
|
}
|
|
}));
|
|
getSymbolAccessibilityDiagnostic = oldDiag2;
|
|
}
|
|
const hasPrivateIdentifier = some(input.members, (member) => !!member.name && isPrivateIdentifier(member.name));
|
|
const privateIdentifier = hasPrivateIdentifier ? [
|
|
factory2.createPropertyDeclaration(
|
|
void 0,
|
|
factory2.createPrivateIdentifier("#private"),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)
|
|
] : void 0;
|
|
const memberNodes = concatenate(concatenate(privateIdentifier, parameterProperties), visitNodes2(input.members, visitDeclarationSubtree));
|
|
const members = factory2.createNodeArray(memberNodes);
|
|
const extendsClause = getEffectiveBaseTypeNode(input);
|
|
if (extendsClause && !isEntityNameExpression(extendsClause.expression) && extendsClause.expression.kind !== 104 /* NullKeyword */) {
|
|
const oldId = input.name ? unescapeLeadingUnderscores(input.name.escapedText) : "default";
|
|
const newId = factory2.createUniqueName(`${oldId}_base`, 16 /* Optimistic */);
|
|
getSymbolAccessibilityDiagnostic = () => ({
|
|
diagnosticMessage: Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
|
|
errorNode: extendsClause,
|
|
typeName: input.name
|
|
});
|
|
const varDecl = factory2.createVariableDeclaration(newId, void 0, resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), void 0);
|
|
const statement = factory2.createVariableStatement(needsDeclare ? [factory2.createModifier(136 /* DeclareKeyword */)] : [], factory2.createVariableDeclarationList([varDecl], 2 /* Const */));
|
|
const heritageClauses = factory2.createNodeArray(map(input.heritageClauses, (clause) => {
|
|
if (clause.token === 94 /* ExtendsKeyword */) {
|
|
const oldDiag2 = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]);
|
|
const newClause = factory2.updateHeritageClause(clause, map(clause.types, (t) => factory2.updateExpressionWithTypeArguments(t, newId, visitNodes2(t.typeArguments, visitDeclarationSubtree))));
|
|
getSymbolAccessibilityDiagnostic = oldDiag2;
|
|
return newClause;
|
|
}
|
|
return factory2.updateHeritageClause(clause, visitNodes2(factory2.createNodeArray(filter(clause.types, (t) => isEntityNameExpression(t.expression) || t.expression.kind === 104 /* NullKeyword */)), visitDeclarationSubtree));
|
|
}));
|
|
return [statement, cleanup(factory2.updateClassDeclaration(
|
|
input,
|
|
modifiers,
|
|
input.name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
))];
|
|
} else {
|
|
const heritageClauses = transformHeritageClauses(input.heritageClauses);
|
|
return cleanup(factory2.updateClassDeclaration(
|
|
input,
|
|
modifiers,
|
|
input.name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
));
|
|
}
|
|
}
|
|
case 240 /* VariableStatement */: {
|
|
return cleanup(transformVariableStatement(input));
|
|
}
|
|
case 263 /* EnumDeclaration */: {
|
|
return cleanup(factory2.updateEnumDeclaration(input, factory2.createNodeArray(ensureModifiers(input)), input.name, factory2.createNodeArray(mapDefined(input.members, (m) => {
|
|
if (shouldStripInternal(m))
|
|
return;
|
|
const constValue = resolver.getConstantValue(m);
|
|
return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
|
|
}))));
|
|
}
|
|
}
|
|
return Debug.assertNever(input, `Unhandled top-level node in declaration emit: ${Debug.formatSyntaxKind(input.kind)}`);
|
|
function cleanup(node) {
|
|
if (isEnclosingDeclaration(input)) {
|
|
enclosingDeclaration = previousEnclosingDeclaration;
|
|
}
|
|
if (canProdiceDiagnostic) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
if (input.kind === 264 /* ModuleDeclaration */) {
|
|
needsDeclare = previousNeedsDeclare;
|
|
}
|
|
if (node === input) {
|
|
return node;
|
|
}
|
|
errorFallbackNode = void 0;
|
|
errorNameNode = void 0;
|
|
return node && setOriginalNode(preserveJsDoc(node, input), input);
|
|
}
|
|
}
|
|
function transformVariableStatement(input) {
|
|
if (!forEach(input.declarationList.declarations, getBindingNameVisible))
|
|
return;
|
|
const nodes = visitNodes2(input.declarationList.declarations, visitDeclarationSubtree);
|
|
if (!length(nodes))
|
|
return;
|
|
return factory2.updateVariableStatement(input, factory2.createNodeArray(ensureModifiers(input)), factory2.updateVariableDeclarationList(input.declarationList, nodes));
|
|
}
|
|
function recreateBindingPattern(d) {
|
|
return flatten(mapDefined(d.elements, (e) => recreateBindingElement(e)));
|
|
}
|
|
function recreateBindingElement(e) {
|
|
if (e.kind === 229 /* OmittedExpression */) {
|
|
return;
|
|
}
|
|
if (e.name) {
|
|
if (!getBindingNameVisible(e))
|
|
return;
|
|
if (isBindingPattern(e.name)) {
|
|
return recreateBindingPattern(e.name);
|
|
} else {
|
|
return factory2.createVariableDeclaration(e.name, void 0, ensureType(e, void 0), void 0);
|
|
}
|
|
}
|
|
}
|
|
function checkName(node) {
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNodeName(node);
|
|
}
|
|
errorNameNode = node.name;
|
|
Debug.assert(resolver.isLateBound(getParseTreeNode(node)));
|
|
const decl = node;
|
|
const entityName = decl.name.expression;
|
|
checkEntityNameVisibility(entityName, enclosingDeclaration);
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
errorNameNode = void 0;
|
|
}
|
|
function shouldStripInternal(node) {
|
|
return !!stripInternal && !!node && isInternalDeclaration(node, currentSourceFile);
|
|
}
|
|
function isScopeMarker2(node) {
|
|
return isExportAssignment(node) || isExportDeclaration(node);
|
|
}
|
|
function hasScopeMarker2(statements) {
|
|
return some(statements, isScopeMarker2);
|
|
}
|
|
function ensureModifiers(node) {
|
|
const currentFlags = getEffectiveModifierFlags(node);
|
|
const newFlags = ensureModifierFlags(node);
|
|
if (currentFlags === newFlags) {
|
|
return visitArray(node.modifiers, (n) => tryCast(n, isModifier), isModifier);
|
|
}
|
|
return factory2.createModifiersFromModifierFlags(newFlags);
|
|
}
|
|
function ensureModifierFlags(node) {
|
|
let mask = 258047 /* All */ ^ (4 /* Public */ | 512 /* Async */ | 16384 /* Override */);
|
|
let additions = needsDeclare && !isAlwaysType(node) ? 2 /* Ambient */ : 0 /* None */;
|
|
const parentIsFile = node.parent.kind === 308 /* SourceFile */;
|
|
if (!parentIsFile || isBundledEmit && parentIsFile && isExternalModule(node.parent)) {
|
|
mask ^= 2 /* Ambient */;
|
|
additions = 0 /* None */;
|
|
}
|
|
return maskModifierFlags(node, mask, additions);
|
|
}
|
|
function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) {
|
|
let accessorType = getTypeAnnotationFromAccessor(node);
|
|
if (!accessorType && node !== accessors.firstAccessor) {
|
|
accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor);
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor);
|
|
}
|
|
if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) {
|
|
accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor);
|
|
}
|
|
return accessorType;
|
|
}
|
|
function transformHeritageClauses(nodes) {
|
|
return factory2.createNodeArray(filter(map(nodes, (clause) => factory2.updateHeritageClause(clause, visitNodes2(factory2.createNodeArray(filter(clause.types, (t) => {
|
|
return isEntityNameExpression(t.expression) || clause.token === 94 /* ExtendsKeyword */ && t.expression.kind === 104 /* NullKeyword */;
|
|
})), visitDeclarationSubtree))), (clause) => clause.types && !!clause.types.length));
|
|
}
|
|
}
|
|
function isAlwaysType(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function maskModifiers(node, modifierMask, modifierAdditions) {
|
|
return factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
|
|
}
|
|
function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
|
|
let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
|
|
if (flags & 1024 /* Default */ && !(flags & 1 /* Export */)) {
|
|
flags ^= 1 /* Export */;
|
|
}
|
|
if (flags & 1024 /* Default */ && flags & 2 /* Ambient */) {
|
|
flags ^= 2 /* Ambient */;
|
|
}
|
|
return flags;
|
|
}
|
|
function getTypeAnnotationFromAccessor(accessor) {
|
|
if (accessor) {
|
|
return accessor.kind === 174 /* GetAccessor */ ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : void 0;
|
|
}
|
|
}
|
|
function canHaveLiteralInitializer(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return !hasEffectiveModifier(node, 8 /* Private */);
|
|
case 166 /* Parameter */:
|
|
case 257 /* VariableDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isPreservedDeclarationStatement(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isProcessedComponent(node) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 257 /* VariableDeclaration */:
|
|
case 165 /* TypeParameter */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 180 /* TypeReference */:
|
|
case 191 /* ConditionalType */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 202 /* ImportType */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// src/compiler/transformer.ts
|
|
function getModuleTransformer(moduleKind) {
|
|
switch (moduleKind) {
|
|
case 99 /* ESNext */:
|
|
case 7 /* ES2022 */:
|
|
case 6 /* ES2020 */:
|
|
case 5 /* ES2015 */:
|
|
return transformECMAScriptModule;
|
|
case 4 /* System */:
|
|
return transformSystemModule;
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return transformNodeModule;
|
|
default:
|
|
return transformModule;
|
|
}
|
|
}
|
|
var noTransformers = { scriptTransformers: emptyArray, declarationTransformers: emptyArray };
|
|
function getTransformers(compilerOptions, customTransformers, emitOnly) {
|
|
return {
|
|
scriptTransformers: getScriptTransformers(compilerOptions, customTransformers, emitOnly),
|
|
declarationTransformers: getDeclarationTransformers(customTransformers)
|
|
};
|
|
}
|
|
function getScriptTransformers(compilerOptions, customTransformers, emitOnly) {
|
|
if (emitOnly)
|
|
return emptyArray;
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const transformers = [];
|
|
addRange(transformers, customTransformers && map(customTransformers.before, wrapScriptTransformerFactory));
|
|
transformers.push(transformTypeScript);
|
|
transformers.push(transformLegacyDecorators);
|
|
transformers.push(transformClassFields);
|
|
if (getJSXTransformEnabled(compilerOptions)) {
|
|
transformers.push(transformJsx);
|
|
}
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
transformers.push(transformESNext);
|
|
}
|
|
if (languageVersion < 8 /* ES2021 */) {
|
|
transformers.push(transformES2021);
|
|
}
|
|
if (languageVersion < 7 /* ES2020 */) {
|
|
transformers.push(transformES2020);
|
|
}
|
|
if (languageVersion < 6 /* ES2019 */) {
|
|
transformers.push(transformES2019);
|
|
}
|
|
if (languageVersion < 5 /* ES2018 */) {
|
|
transformers.push(transformES2018);
|
|
}
|
|
if (languageVersion < 4 /* ES2017 */) {
|
|
transformers.push(transformES2017);
|
|
}
|
|
if (languageVersion < 3 /* ES2016 */) {
|
|
transformers.push(transformES2016);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
transformers.push(transformES2015);
|
|
transformers.push(transformGenerators);
|
|
}
|
|
transformers.push(getModuleTransformer(moduleKind));
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
transformers.push(transformES5);
|
|
}
|
|
addRange(transformers, customTransformers && map(customTransformers.after, wrapScriptTransformerFactory));
|
|
return transformers;
|
|
}
|
|
function getDeclarationTransformers(customTransformers) {
|
|
const transformers = [];
|
|
transformers.push(transformDeclarations);
|
|
addRange(transformers, customTransformers && map(customTransformers.afterDeclarations, wrapDeclarationTransformerFactory));
|
|
return transformers;
|
|
}
|
|
function wrapCustomTransformer(transformer) {
|
|
return (node) => isBundle(node) ? transformer.transformBundle(node) : transformer.transformSourceFile(node);
|
|
}
|
|
function wrapCustomTransformerFactory(transformer, handleDefault) {
|
|
return (context) => {
|
|
const customTransformer = transformer(context);
|
|
return typeof customTransformer === "function" ? handleDefault(context, customTransformer) : wrapCustomTransformer(customTransformer);
|
|
};
|
|
}
|
|
function wrapScriptTransformerFactory(transformer) {
|
|
return wrapCustomTransformerFactory(transformer, chainBundle);
|
|
}
|
|
function wrapDeclarationTransformerFactory(transformer) {
|
|
return wrapCustomTransformerFactory(transformer, (_, node) => node);
|
|
}
|
|
function noEmitSubstitution(_hint, node) {
|
|
return node;
|
|
}
|
|
function noEmitNotification(hint, node, callback) {
|
|
callback(hint, node);
|
|
}
|
|
function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
|
|
var _a2, _b;
|
|
const enabledSyntaxKindFeatures = new Array(358 /* Count */);
|
|
let lexicalEnvironmentVariableDeclarations;
|
|
let lexicalEnvironmentFunctionDeclarations;
|
|
let lexicalEnvironmentStatements;
|
|
let lexicalEnvironmentFlags = 0 /* None */;
|
|
let lexicalEnvironmentVariableDeclarationsStack = [];
|
|
let lexicalEnvironmentFunctionDeclarationsStack = [];
|
|
let lexicalEnvironmentStatementsStack = [];
|
|
let lexicalEnvironmentFlagsStack = [];
|
|
let lexicalEnvironmentStackOffset = 0;
|
|
let lexicalEnvironmentSuspended = false;
|
|
let blockScopedVariableDeclarationsStack = [];
|
|
let blockScopeStackOffset = 0;
|
|
let blockScopedVariableDeclarations;
|
|
let emitHelpers;
|
|
let onSubstituteNode = noEmitSubstitution;
|
|
let onEmitNode = noEmitNotification;
|
|
let state = 0 /* Uninitialized */;
|
|
const diagnostics = [];
|
|
const context = {
|
|
factory: factory2,
|
|
getCompilerOptions: () => options,
|
|
getEmitResolver: () => resolver,
|
|
getEmitHost: () => host,
|
|
getEmitHelperFactory: memoize(() => createEmitHelperFactory(context)),
|
|
startLexicalEnvironment,
|
|
suspendLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
setLexicalEnvironmentFlags,
|
|
getLexicalEnvironmentFlags,
|
|
hoistVariableDeclaration,
|
|
hoistFunctionDeclaration,
|
|
addInitializationStatement,
|
|
startBlockScope,
|
|
endBlockScope,
|
|
addBlockScopedVariable,
|
|
requestEmitHelper,
|
|
readEmitHelpers,
|
|
enableSubstitution,
|
|
enableEmitNotification,
|
|
isSubstitutionEnabled,
|
|
isEmitNotificationEnabled,
|
|
get onSubstituteNode() {
|
|
return onSubstituteNode;
|
|
},
|
|
set onSubstituteNode(value) {
|
|
Debug.assert(state < 1 /* Initialized */, "Cannot modify transformation hooks after initialization has completed.");
|
|
Debug.assert(value !== void 0, "Value must not be 'undefined'");
|
|
onSubstituteNode = value;
|
|
},
|
|
get onEmitNode() {
|
|
return onEmitNode;
|
|
},
|
|
set onEmitNode(value) {
|
|
Debug.assert(state < 1 /* Initialized */, "Cannot modify transformation hooks after initialization has completed.");
|
|
Debug.assert(value !== void 0, "Value must not be 'undefined'");
|
|
onEmitNode = value;
|
|
},
|
|
addDiagnostic(diag2) {
|
|
diagnostics.push(diag2);
|
|
}
|
|
};
|
|
for (const node of nodes) {
|
|
disposeEmitNodes(getSourceFileOfNode(getParseTreeNode(node)));
|
|
}
|
|
mark("beforeTransform");
|
|
const transformersWithContext = transformers.map((t) => t(context));
|
|
const transformation = (node) => {
|
|
for (const transform of transformersWithContext) {
|
|
node = transform(node);
|
|
}
|
|
return node;
|
|
};
|
|
state = 1 /* Initialized */;
|
|
const transformed = [];
|
|
for (const node of nodes) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "transformNodes", node.kind === 308 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end });
|
|
transformed.push((allowDtsFiles ? transformation : transformRoot)(node));
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
state = 2 /* Completed */;
|
|
mark("afterTransform");
|
|
measure("transformTime", "beforeTransform", "afterTransform");
|
|
return {
|
|
transformed,
|
|
substituteNode,
|
|
emitNodeWithNotification,
|
|
isEmitNotificationEnabled,
|
|
dispose,
|
|
diagnostics
|
|
};
|
|
function transformRoot(node) {
|
|
return node && (!isSourceFile(node) || !node.isDeclarationFile) ? transformation(node) : node;
|
|
}
|
|
function enableSubstitution(kind) {
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
enabledSyntaxKindFeatures[kind] |= 1 /* Substitution */;
|
|
}
|
|
function isSubstitutionEnabled(node) {
|
|
return (enabledSyntaxKindFeatures[node.kind] & 1 /* Substitution */) !== 0 && (getEmitFlags(node) & 8 /* NoSubstitution */) === 0;
|
|
}
|
|
function substituteNode(hint, node) {
|
|
Debug.assert(state < 3 /* Disposed */, "Cannot substitute a node after the result is disposed.");
|
|
return node && isSubstitutionEnabled(node) && onSubstituteNode(hint, node) || node;
|
|
}
|
|
function enableEmitNotification(kind) {
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
enabledSyntaxKindFeatures[kind] |= 2 /* EmitNotifications */;
|
|
}
|
|
function isEmitNotificationEnabled(node) {
|
|
return (enabledSyntaxKindFeatures[node.kind] & 2 /* EmitNotifications */) !== 0 || (getEmitFlags(node) & 4 /* AdviseOnEmitNode */) !== 0;
|
|
}
|
|
function emitNodeWithNotification(hint, node, emitCallback) {
|
|
Debug.assert(state < 3 /* Disposed */, "Cannot invoke TransformationResult callbacks after the result is disposed.");
|
|
if (node) {
|
|
if (isEmitNotificationEnabled(node)) {
|
|
onEmitNode(hint, node, emitCallback);
|
|
} else {
|
|
emitCallback(hint, node);
|
|
}
|
|
}
|
|
}
|
|
function hoistVariableDeclaration(name) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
const decl = setEmitFlags(factory2.createVariableDeclaration(name), 128 /* NoNestedSourceMaps */);
|
|
if (!lexicalEnvironmentVariableDeclarations) {
|
|
lexicalEnvironmentVariableDeclarations = [decl];
|
|
} else {
|
|
lexicalEnvironmentVariableDeclarations.push(decl);
|
|
}
|
|
if (lexicalEnvironmentFlags & 1 /* InParameters */) {
|
|
lexicalEnvironmentFlags |= 2 /* VariablesHoistedInParameters */;
|
|
}
|
|
}
|
|
function hoistFunctionDeclaration(func) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
setEmitFlags(func, 2097152 /* CustomPrologue */);
|
|
if (!lexicalEnvironmentFunctionDeclarations) {
|
|
lexicalEnvironmentFunctionDeclarations = [func];
|
|
} else {
|
|
lexicalEnvironmentFunctionDeclarations.push(func);
|
|
}
|
|
}
|
|
function addInitializationStatement(node) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
setEmitFlags(node, 2097152 /* CustomPrologue */);
|
|
if (!lexicalEnvironmentStatements) {
|
|
lexicalEnvironmentStatements = [node];
|
|
} else {
|
|
lexicalEnvironmentStatements.push(node);
|
|
}
|
|
}
|
|
function startLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended.");
|
|
lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentVariableDeclarations;
|
|
lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFunctionDeclarations;
|
|
lexicalEnvironmentStatementsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentStatements;
|
|
lexicalEnvironmentFlagsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFlags;
|
|
lexicalEnvironmentStackOffset++;
|
|
lexicalEnvironmentVariableDeclarations = void 0;
|
|
lexicalEnvironmentFunctionDeclarations = void 0;
|
|
lexicalEnvironmentStatements = void 0;
|
|
lexicalEnvironmentFlags = 0 /* None */;
|
|
}
|
|
function suspendLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is already suspended.");
|
|
lexicalEnvironmentSuspended = true;
|
|
}
|
|
function resumeLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(lexicalEnvironmentSuspended, "Lexical environment is not suspended.");
|
|
lexicalEnvironmentSuspended = false;
|
|
}
|
|
function endLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended.");
|
|
let statements;
|
|
if (lexicalEnvironmentVariableDeclarations || lexicalEnvironmentFunctionDeclarations || lexicalEnvironmentStatements) {
|
|
if (lexicalEnvironmentFunctionDeclarations) {
|
|
statements = [...lexicalEnvironmentFunctionDeclarations];
|
|
}
|
|
if (lexicalEnvironmentVariableDeclarations) {
|
|
const statement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations)
|
|
);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
if (!statements) {
|
|
statements = [statement];
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
if (lexicalEnvironmentStatements) {
|
|
if (!statements) {
|
|
statements = [...lexicalEnvironmentStatements];
|
|
} else {
|
|
statements = [...statements, ...lexicalEnvironmentStatements];
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
function startBlockScope() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot start a block scope during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot start a block scope after transformation has completed.");
|
|
blockScopedVariableDeclarationsStack[blockScopeStackOffset] = blockScopedVariableDeclarations;
|
|
blockScopeStackOffset++;
|
|
blockScopedVariableDeclarations = void 0;
|
|
}
|
|
function endBlockScope() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot end a block scope during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot end a block scope after transformation has completed.");
|
|
const statements = some(blockScopedVariableDeclarations) ? [
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
blockScopedVariableDeclarations.map((identifier) => factory2.createVariableDeclaration(identifier)),
|
|
1 /* Let */
|
|
)
|
|
)
|
|
] : void 0;
|
|
blockScopeStackOffset--;
|
|
blockScopedVariableDeclarations = blockScopedVariableDeclarationsStack[blockScopeStackOffset];
|
|
if (blockScopeStackOffset === 0) {
|
|
blockScopedVariableDeclarationsStack = [];
|
|
}
|
|
return statements;
|
|
}
|
|
function addBlockScopedVariable(name) {
|
|
Debug.assert(blockScopeStackOffset > 0, "Cannot add a block scoped variable outside of an iteration body.");
|
|
(blockScopedVariableDeclarations || (blockScopedVariableDeclarations = [])).push(name);
|
|
}
|
|
function requestEmitHelper(helper) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the transformation context during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
Debug.assert(!helper.scoped, "Cannot request a scoped emit helper.");
|
|
if (helper.dependencies) {
|
|
for (const h of helper.dependencies) {
|
|
requestEmitHelper(h);
|
|
}
|
|
}
|
|
emitHelpers = append(emitHelpers, helper);
|
|
}
|
|
function readEmitHelpers() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the transformation context during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
const helpers = emitHelpers;
|
|
emitHelpers = void 0;
|
|
return helpers;
|
|
}
|
|
function dispose() {
|
|
if (state < 3 /* Disposed */) {
|
|
for (const node of nodes) {
|
|
disposeEmitNodes(getSourceFileOfNode(getParseTreeNode(node)));
|
|
}
|
|
lexicalEnvironmentVariableDeclarations = void 0;
|
|
lexicalEnvironmentVariableDeclarationsStack = void 0;
|
|
lexicalEnvironmentFunctionDeclarations = void 0;
|
|
lexicalEnvironmentFunctionDeclarationsStack = void 0;
|
|
onSubstituteNode = void 0;
|
|
onEmitNode = void 0;
|
|
emitHelpers = void 0;
|
|
state = 3 /* Disposed */;
|
|
}
|
|
}
|
|
}
|
|
var nullTransformationContext = {
|
|
factory,
|
|
getCompilerOptions: () => ({}),
|
|
getEmitResolver: notImplemented,
|
|
getEmitHost: notImplemented,
|
|
getEmitHelperFactory: notImplemented,
|
|
startLexicalEnvironment: noop,
|
|
resumeLexicalEnvironment: noop,
|
|
suspendLexicalEnvironment: noop,
|
|
endLexicalEnvironment: returnUndefined,
|
|
setLexicalEnvironmentFlags: noop,
|
|
getLexicalEnvironmentFlags: () => 0,
|
|
hoistVariableDeclaration: noop,
|
|
hoistFunctionDeclaration: noop,
|
|
addInitializationStatement: noop,
|
|
startBlockScope: noop,
|
|
endBlockScope: returnUndefined,
|
|
addBlockScopedVariable: noop,
|
|
requestEmitHelper: noop,
|
|
readEmitHelpers: notImplemented,
|
|
enableSubstitution: noop,
|
|
enableEmitNotification: noop,
|
|
isSubstitutionEnabled: notImplemented,
|
|
isEmitNotificationEnabled: notImplemented,
|
|
onSubstituteNode: noEmitSubstitution,
|
|
onEmitNode: noEmitNotification,
|
|
addDiagnostic: noop
|
|
};
|
|
|
|
// src/compiler/emitter.ts
|
|
var brackets = createBracketsMap();
|
|
function isBuildInfoFile(file) {
|
|
return fileExtensionIs(file, ".tsbuildinfo" /* TsBuildInfo */);
|
|
}
|
|
function forEachEmittedFile(host, action, sourceFilesOrTargetSourceFile, forceDtsEmit = false, onlyBuildInfo, includeBuildInfo) {
|
|
const sourceFiles = isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit);
|
|
const options = host.getCompilerOptions();
|
|
if (outFile(options)) {
|
|
const prepends = host.getPrependNodes();
|
|
if (sourceFiles.length || prepends.length) {
|
|
const bundle = factory.createBundle(sourceFiles, prepends);
|
|
const result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
} else {
|
|
if (!onlyBuildInfo) {
|
|
for (const sourceFile of sourceFiles) {
|
|
const result = action(getOutputPathsFor(sourceFile, host, forceDtsEmit), sourceFile);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
if (includeBuildInfo) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
if (buildInfoPath)
|
|
return action({ buildInfoPath }, void 0);
|
|
}
|
|
}
|
|
}
|
|
function getTsBuildInfoEmitOutputFilePath(options) {
|
|
const configFile = options.configFilePath;
|
|
if (!isIncrementalCompilation(options))
|
|
return void 0;
|
|
if (options.tsBuildInfoFile)
|
|
return options.tsBuildInfoFile;
|
|
const outPath = outFile(options);
|
|
let buildInfoExtensionLess;
|
|
if (outPath) {
|
|
buildInfoExtensionLess = removeFileExtension(outPath);
|
|
} else {
|
|
if (!configFile)
|
|
return void 0;
|
|
const configFileExtensionLess = removeFileExtension(configFile);
|
|
buildInfoExtensionLess = options.outDir ? options.rootDir ? resolvePath(options.outDir, getRelativePathFromDirectory(options.rootDir, configFileExtensionLess, true)) : combinePaths(options.outDir, getBaseFileName(configFileExtensionLess)) : configFileExtensionLess;
|
|
}
|
|
return buildInfoExtensionLess + ".tsbuildinfo" /* TsBuildInfo */;
|
|
}
|
|
function getOutputPathsForBundle(options, forceDtsPaths) {
|
|
const outPath = outFile(options);
|
|
const jsFilePath = options.emitDeclarationOnly ? void 0 : outPath;
|
|
const sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options);
|
|
const declarationFilePath = forceDtsPaths || getEmitDeclarations(options) ? removeFileExtension(outPath) + ".d.ts" /* Dts */ : void 0;
|
|
const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : void 0;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath };
|
|
}
|
|
function getOutputPathsFor(sourceFile, host, forceDtsPaths) {
|
|
const options = host.getCompilerOptions();
|
|
if (sourceFile.kind === 309 /* Bundle */) {
|
|
return getOutputPathsForBundle(options, forceDtsPaths);
|
|
} else {
|
|
const ownOutputFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile.fileName, options));
|
|
const isJsonFile = isJsonSourceFile(sourceFile);
|
|
const isJsonEmittedToSameLocation = isJsonFile && comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === 0 /* EqualTo */;
|
|
const jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? void 0 : ownOutputFilePath;
|
|
const sourceMapFilePath = !jsFilePath || isJsonSourceFile(sourceFile) ? void 0 : getSourceMapFilePath(jsFilePath, options);
|
|
const declarationFilePath = forceDtsPaths || getEmitDeclarations(options) && !isJsonFile ? getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : void 0;
|
|
const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : void 0;
|
|
return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath: void 0 };
|
|
}
|
|
}
|
|
function getSourceMapFilePath(jsFilePath, options) {
|
|
return options.sourceMap && !options.inlineSourceMap ? jsFilePath + ".map" : void 0;
|
|
}
|
|
function getOutputExtension(fileName, options) {
|
|
return fileExtensionIs(fileName, ".json" /* Json */) ? ".json" /* Json */ : options.jsx === 1 /* Preserve */ && fileExtensionIsOneOf(fileName, [".jsx" /* Jsx */, ".tsx" /* Tsx */]) ? ".jsx" /* Jsx */ : fileExtensionIsOneOf(fileName, [".mts" /* Mts */, ".mjs" /* Mjs */]) ? ".mjs" /* Mjs */ : fileExtensionIsOneOf(fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]) ? ".cjs" /* Cjs */ : ".js" /* Js */;
|
|
}
|
|
function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory2) {
|
|
return outputDir ? resolvePath(
|
|
outputDir,
|
|
getRelativePathFromDirectory(getCommonSourceDirectory2 ? getCommonSourceDirectory2() : getCommonSourceDirectoryOfConfig(configFile, ignoreCase), inputFileName, ignoreCase)
|
|
) : inputFileName;
|
|
}
|
|
function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
|
|
return changeExtension(
|
|
getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory2),
|
|
getDeclarationEmitExtensionForPath(inputFileName)
|
|
);
|
|
}
|
|
function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
|
|
if (configFile.options.emitDeclarationOnly)
|
|
return void 0;
|
|
const isJsonFile = fileExtensionIs(inputFileName, ".json" /* Json */);
|
|
const outputFileName = changeExtension(
|
|
getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory2),
|
|
getOutputExtension(inputFileName, configFile.options)
|
|
);
|
|
return !isJsonFile || comparePaths(inputFileName, outputFileName, Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 /* EqualTo */ ? outputFileName : void 0;
|
|
}
|
|
function createAddOutput() {
|
|
let outputs;
|
|
return { addOutput, getOutputs };
|
|
function addOutput(path) {
|
|
if (path) {
|
|
(outputs || (outputs = [])).push(path);
|
|
}
|
|
}
|
|
function getOutputs() {
|
|
return outputs || emptyArray;
|
|
}
|
|
}
|
|
function getSingleOutputFileNames(configFile, addOutput) {
|
|
const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(configFile.options, false);
|
|
addOutput(jsFilePath);
|
|
addOutput(sourceMapFilePath);
|
|
addOutput(declarationFilePath);
|
|
addOutput(declarationMapPath);
|
|
addOutput(buildInfoPath);
|
|
}
|
|
function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory2) {
|
|
if (isDeclarationFileName(inputFileName))
|
|
return;
|
|
const js = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
addOutput(js);
|
|
if (fileExtensionIs(inputFileName, ".json" /* Json */))
|
|
return;
|
|
if (js && configFile.options.sourceMap) {
|
|
addOutput(`${js}.map`);
|
|
}
|
|
if (getEmitDeclarations(configFile.options)) {
|
|
const dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
addOutput(dts);
|
|
if (configFile.options.declarationMap) {
|
|
addOutput(`${dts}.map`);
|
|
}
|
|
}
|
|
}
|
|
function getCommonSourceDirectory(options, emittedFiles, currentDirectory, getCanonicalFileName, checkSourceFilesBelongToPath) {
|
|
let commonSourceDirectory;
|
|
if (options.rootDir) {
|
|
commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);
|
|
checkSourceFilesBelongToPath == null ? void 0 : checkSourceFilesBelongToPath(options.rootDir);
|
|
} else if (options.composite && options.configFilePath) {
|
|
commonSourceDirectory = getDirectoryPath(normalizeSlashes(options.configFilePath));
|
|
checkSourceFilesBelongToPath == null ? void 0 : checkSourceFilesBelongToPath(commonSourceDirectory);
|
|
} else {
|
|
commonSourceDirectory = computeCommonSourceDirectoryOfFilenames(emittedFiles(), currentDirectory, getCanonicalFileName);
|
|
}
|
|
if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) {
|
|
commonSourceDirectory += directorySeparator;
|
|
}
|
|
return commonSourceDirectory;
|
|
}
|
|
function getCommonSourceDirectoryOfConfig({ options, fileNames }, ignoreCase) {
|
|
return getCommonSourceDirectory(
|
|
options,
|
|
() => filter(fileNames, (file) => !(options.noEmitForJsFiles && fileExtensionIsOneOf(file, supportedJSExtensionsFlat)) && !isDeclarationFileName(file)),
|
|
getDirectoryPath(normalizeSlashes(Debug.checkDefined(options.configFilePath))),
|
|
createGetCanonicalFileName(!ignoreCase)
|
|
);
|
|
}
|
|
function getAllProjectOutputs(configFile, ignoreCase) {
|
|
const { addOutput, getOutputs } = createAddOutput();
|
|
if (outFile(configFile.options)) {
|
|
getSingleOutputFileNames(configFile, addOutput);
|
|
} else {
|
|
const getCommonSourceDirectory2 = memoize(() => getCommonSourceDirectoryOfConfig(configFile, ignoreCase));
|
|
for (const inputFileName of configFile.fileNames) {
|
|
getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory2);
|
|
}
|
|
addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options));
|
|
}
|
|
return getOutputs();
|
|
}
|
|
function getFirstProjectOutput(configFile, ignoreCase) {
|
|
if (outFile(configFile.options)) {
|
|
const { jsFilePath, declarationFilePath } = getOutputPathsForBundle(configFile.options, false);
|
|
return Debug.checkDefined(jsFilePath || declarationFilePath, `project ${configFile.options.configFilePath} expected to have at least one output`);
|
|
}
|
|
const getCommonSourceDirectory2 = memoize(() => getCommonSourceDirectoryOfConfig(configFile, ignoreCase));
|
|
for (const inputFileName of configFile.fileNames) {
|
|
if (isDeclarationFileName(inputFileName))
|
|
continue;
|
|
const jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
if (jsFilePath)
|
|
return jsFilePath;
|
|
if (fileExtensionIs(inputFileName, ".json" /* Json */))
|
|
continue;
|
|
if (getEmitDeclarations(configFile.options)) {
|
|
return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
}
|
|
}
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options);
|
|
if (buildInfoPath)
|
|
return buildInfoPath;
|
|
return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);
|
|
}
|
|
function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
|
|
const emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const newLine = getNewLineCharacter(compilerOptions, () => host.getNewLine());
|
|
const writer = createTextWriter(newLine);
|
|
const { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
|
|
let bundleBuildInfo;
|
|
let emitSkipped = false;
|
|
enter();
|
|
forEachEmittedFile(
|
|
host,
|
|
emitSourceFileOrBundle,
|
|
getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit),
|
|
forceDtsEmit,
|
|
onlyBuildInfo,
|
|
!targetSourceFile
|
|
);
|
|
exit();
|
|
return {
|
|
emitSkipped,
|
|
diagnostics: emitterDiagnostics.getDiagnostics(),
|
|
emittedFiles: emittedFilesList,
|
|
sourceMaps: sourceMapDataList
|
|
};
|
|
function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath }, sourceFileOrBundle) {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
let buildInfoDirectory;
|
|
if (buildInfoPath && sourceFileOrBundle && isBundle(sourceFileOrBundle)) {
|
|
buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
bundleBuildInfo = {
|
|
commonSourceDirectory: relativeToBuildInfo(host.getCommonSourceDirectory()),
|
|
sourceFiles: sourceFileOrBundle.sourceFiles.map((file) => relativeToBuildInfo(getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())))
|
|
};
|
|
}
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitJsFileOrBundle", { jsFilePath });
|
|
emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
(_c = tracing) == null ? void 0 : _c.push(tracing.Phase.Emit, "emitDeclarationFileOrBundle", { declarationFilePath });
|
|
emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);
|
|
(_d = tracing) == null ? void 0 : _d.pop();
|
|
(_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Emit, "emitBuildInfo", { buildInfoPath });
|
|
emitBuildInfo(bundleBuildInfo, buildInfoPath);
|
|
(_f = tracing) == null ? void 0 : _f.pop();
|
|
if (!emitSkipped && emittedFilesList) {
|
|
if (!emitOnly) {
|
|
if (jsFilePath) {
|
|
emittedFilesList.push(jsFilePath);
|
|
}
|
|
if (sourceMapFilePath) {
|
|
emittedFilesList.push(sourceMapFilePath);
|
|
}
|
|
if (buildInfoPath) {
|
|
emittedFilesList.push(buildInfoPath);
|
|
}
|
|
}
|
|
if (emitOnly !== 0 /* Js */) {
|
|
if (declarationFilePath) {
|
|
emittedFilesList.push(declarationFilePath);
|
|
}
|
|
if (declarationMapPath) {
|
|
emittedFilesList.push(declarationMapPath);
|
|
}
|
|
}
|
|
}
|
|
function relativeToBuildInfo(path) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName));
|
|
}
|
|
}
|
|
function emitBuildInfo(bundle, buildInfoPath) {
|
|
if (!buildInfoPath || targetSourceFile || emitSkipped)
|
|
return;
|
|
if (host.isEmitBlocked(buildInfoPath)) {
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const buildInfo = host.getBuildInfo(bundle) || createBuildInfo(void 0, bundle);
|
|
writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), false, void 0, { buildInfo });
|
|
}
|
|
function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
|
|
if (!sourceFileOrBundle || emitOnly || !jsFilePath) {
|
|
return;
|
|
}
|
|
if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit) {
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const transform = transformNodes(resolver, host, factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, false);
|
|
const 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
|
|
};
|
|
const printer = createPrinter(printerOptions, {
|
|
hasGlobalName: resolver.hasGlobalName,
|
|
onEmitNode: transform.emitNodeWithNotification,
|
|
isEmitNotificationEnabled: transform.isEmitNotificationEnabled,
|
|
substituteNode: transform.substituteNode
|
|
});
|
|
Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");
|
|
printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, compilerOptions);
|
|
transform.dispose();
|
|
if (bundleBuildInfo)
|
|
bundleBuildInfo.js = printer.bundleFileInfo;
|
|
}
|
|
function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) {
|
|
if (!sourceFileOrBundle || emitOnly === 0 /* Js */)
|
|
return;
|
|
if (!declarationFilePath) {
|
|
if (emitOnly || compilerOptions.emitDeclarationOnly)
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const sourceFiles = isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;
|
|
const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);
|
|
const inputListOrBundle = outFile(compilerOptions) ? [factory.createBundle(filesForEmit, !isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : void 0)] : filesForEmit;
|
|
if (emitOnly && !getEmitDeclarations(compilerOptions)) {
|
|
filesForEmit.forEach(collectLinkedAliases);
|
|
}
|
|
const declarationTransform = transformNodes(resolver, host, factory, compilerOptions, inputListOrBundle, declarationTransformers, false);
|
|
if (length(declarationTransform.diagnostics)) {
|
|
for (const diagnostic of declarationTransform.diagnostics) {
|
|
emitterDiagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
const 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
|
|
};
|
|
const declarationPrinter = createPrinter(printerOptions, {
|
|
hasGlobalName: resolver.hasGlobalName,
|
|
onEmitNode: declarationTransform.emitNodeWithNotification,
|
|
isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
|
|
substituteNode: declarationTransform.substituteNode
|
|
});
|
|
const declBlocked = !!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
|
|
emitSkipped = emitSkipped || declBlocked;
|
|
if (!declBlocked || forceDtsEmit) {
|
|
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
|
|
}
|
|
);
|
|
}
|
|
declarationTransform.dispose();
|
|
if (bundleBuildInfo)
|
|
bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
|
|
}
|
|
function collectLinkedAliases(node) {
|
|
if (isExportAssignment(node)) {
|
|
if (node.expression.kind === 79 /* Identifier */) {
|
|
resolver.collectLinkedAliases(node.expression, true);
|
|
}
|
|
return;
|
|
} else if (isExportSpecifier(node)) {
|
|
resolver.collectLinkedAliases(node.propertyName || node.name, true);
|
|
return;
|
|
}
|
|
forEachChild(node, collectLinkedAliases);
|
|
}
|
|
function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, mapOptions) {
|
|
const sourceFileOrBundle = transform.transformed[0];
|
|
const bundle = sourceFileOrBundle.kind === 309 /* Bundle */ ? sourceFileOrBundle : void 0;
|
|
const sourceFile = sourceFileOrBundle.kind === 308 /* SourceFile */ ? sourceFileOrBundle : void 0;
|
|
const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
|
|
let sourceMapGenerator;
|
|
if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) {
|
|
sourceMapGenerator = createSourceMapGenerator(
|
|
host,
|
|
getBaseFileName(normalizeSlashes(jsFilePath)),
|
|
getSourceRoot(mapOptions),
|
|
getSourceMapDirectory(mapOptions, jsFilePath, sourceFile),
|
|
mapOptions
|
|
);
|
|
}
|
|
if (bundle) {
|
|
printer.writeBundle(bundle, writer, sourceMapGenerator);
|
|
} else {
|
|
printer.writeFile(sourceFile, writer, sourceMapGenerator);
|
|
}
|
|
let sourceMapUrlPos;
|
|
if (sourceMapGenerator) {
|
|
if (sourceMapDataList) {
|
|
sourceMapDataList.push({
|
|
inputSourceFileNames: sourceMapGenerator.getSources(),
|
|
sourceMap: sourceMapGenerator.toJSON()
|
|
});
|
|
}
|
|
const sourceMappingURL = getSourceMappingURL(
|
|
mapOptions,
|
|
sourceMapGenerator,
|
|
jsFilePath,
|
|
sourceMapFilePath,
|
|
sourceFile
|
|
);
|
|
if (sourceMappingURL) {
|
|
if (!writer.isAtStartOfLine())
|
|
writer.rawWrite(newLine);
|
|
sourceMapUrlPos = writer.getTextPos();
|
|
writer.writeComment(`//# ${"sourceMappingURL"}=${sourceMappingURL}`);
|
|
}
|
|
if (sourceMapFilePath) {
|
|
const sourceMap = sourceMapGenerator.toString();
|
|
writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
|
|
if (printer.bundleFileInfo)
|
|
printer.bundleFileInfo.mapHash = computeSignature(sourceMap, host);
|
|
}
|
|
} else {
|
|
writer.writeLine();
|
|
}
|
|
const text = writer.getText();
|
|
writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos, diagnostics: transform.diagnostics });
|
|
if (printer.bundleFileInfo)
|
|
printer.bundleFileInfo.hash = computeSignature(text, host);
|
|
writer.clear();
|
|
}
|
|
function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
|
|
return (mapOptions.sourceMap || mapOptions.inlineSourceMap) && (sourceFileOrBundle.kind !== 308 /* SourceFile */ || !fileExtensionIs(sourceFileOrBundle.fileName, ".json" /* Json */));
|
|
}
|
|
function getSourceRoot(mapOptions) {
|
|
const sourceRoot = normalizeSlashes(mapOptions.sourceRoot || "");
|
|
return sourceRoot ? ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot;
|
|
}
|
|
function getSourceMapDirectory(mapOptions, filePath, sourceFile) {
|
|
if (mapOptions.sourceRoot)
|
|
return host.getCommonSourceDirectory();
|
|
if (mapOptions.mapRoot) {
|
|
let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);
|
|
if (sourceFile) {
|
|
sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));
|
|
}
|
|
if (getRootLength(sourceMapDir) === 0) {
|
|
sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
|
|
}
|
|
return sourceMapDir;
|
|
}
|
|
return getDirectoryPath(normalizePath(filePath));
|
|
}
|
|
function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile) {
|
|
if (mapOptions.inlineSourceMap) {
|
|
const sourceMapText = sourceMapGenerator.toString();
|
|
const base64SourceMapText = base64encode(sys, sourceMapText);
|
|
return `data:application/json;base64,${base64SourceMapText}`;
|
|
}
|
|
const sourceMapFile = getBaseFileName(normalizeSlashes(Debug.checkDefined(sourceMapFilePath)));
|
|
if (mapOptions.mapRoot) {
|
|
let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);
|
|
if (sourceFile) {
|
|
sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));
|
|
}
|
|
if (getRootLength(sourceMapDir) === 0) {
|
|
sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
|
|
return encodeURI(
|
|
getRelativePathToDirectoryOrUrl(
|
|
getDirectoryPath(normalizePath(filePath)),
|
|
combinePaths(sourceMapDir, sourceMapFile),
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
true
|
|
)
|
|
);
|
|
} else {
|
|
return encodeURI(combinePaths(sourceMapDir, sourceMapFile));
|
|
}
|
|
}
|
|
return encodeURI(sourceMapFile);
|
|
}
|
|
}
|
|
function createBuildInfo(program, bundle) {
|
|
const version2 = version;
|
|
return { bundle, program, version: version2 };
|
|
}
|
|
function getBuildInfoText(buildInfo) {
|
|
return JSON.stringify(buildInfo);
|
|
}
|
|
function getBuildInfo(buildInfoFile, buildInfoText) {
|
|
return readJsonOrUndefined(buildInfoFile, buildInfoText);
|
|
}
|
|
var notImplementedResolver = {
|
|
hasGlobalName: notImplemented,
|
|
getReferencedExportContainer: notImplemented,
|
|
getReferencedImportDeclaration: notImplemented,
|
|
getReferencedDeclarationWithCollidingName: notImplemented,
|
|
isDeclarationWithCollidingName: notImplemented,
|
|
isValueAliasDeclaration: notImplemented,
|
|
isReferencedAliasDeclaration: notImplemented,
|
|
isTopLevelValueImportEqualsWithEntityName: notImplemented,
|
|
getNodeCheckFlags: notImplemented,
|
|
isDeclarationVisible: notImplemented,
|
|
isLateBound: (_node) => false,
|
|
collectLinkedAliases: notImplemented,
|
|
isImplementationOfOverload: notImplemented,
|
|
isRequiredInitializedParameter: notImplemented,
|
|
isOptionalUninitializedParameterProperty: notImplemented,
|
|
isExpandoFunctionDeclaration: notImplemented,
|
|
getPropertiesOfContainerFunction: notImplemented,
|
|
createTypeOfDeclaration: notImplemented,
|
|
createReturnTypeOfSignatureDeclaration: notImplemented,
|
|
createTypeOfExpression: notImplemented,
|
|
createLiteralConstValue: notImplemented,
|
|
isSymbolAccessible: notImplemented,
|
|
isEntityNameVisible: notImplemented,
|
|
getConstantValue: notImplemented,
|
|
getReferencedValueDeclaration: notImplemented,
|
|
getTypeReferenceSerializationKind: notImplemented,
|
|
isOptionalParameter: notImplemented,
|
|
moduleExportsSomeValue: notImplemented,
|
|
isArgumentsLocalBinding: notImplemented,
|
|
getExternalModuleFileFromDeclaration: notImplemented,
|
|
getTypeReferenceDirectivesForEntityName: notImplemented,
|
|
getTypeReferenceDirectivesForSymbol: notImplemented,
|
|
isLiteralConstDeclaration: notImplemented,
|
|
getJsxFactoryEntity: notImplemented,
|
|
getJsxFragmentFactoryEntity: notImplemented,
|
|
getAllAccessorDeclarations: notImplemented,
|
|
getSymbolOfExternalModuleSpecifier: notImplemented,
|
|
isBindingCapturedByNode: notImplemented,
|
|
getDeclarationStatementsForSourceFile: notImplemented,
|
|
isImportRequiredByAugmentation: notImplemented
|
|
};
|
|
function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host) {
|
|
var _a2;
|
|
const jsBundle = Debug.checkDefined(bundle.js);
|
|
const prologueMap = ((_a2 = jsBundle.sources) == null ? void 0 : _a2.prologues) && arrayToMap(jsBundle.sources.prologues, (prologueInfo) => prologueInfo.file);
|
|
return bundle.sourceFiles.map((fileName, index) => {
|
|
var _a3, _b;
|
|
const prologueInfo = prologueMap == null ? void 0 : prologueMap.get(index);
|
|
const statements = prologueInfo == null ? void 0 : prologueInfo.directives.map((directive) => {
|
|
const literal = setTextRange(factory.createStringLiteral(directive.expression.text), directive.expression);
|
|
const statement = setTextRange(factory.createExpressionStatement(literal), directive);
|
|
setParent(literal, statement);
|
|
return statement;
|
|
});
|
|
const eofToken = factory.createToken(1 /* EndOfFileToken */);
|
|
const sourceFile = factory.createSourceFile(statements != null ? statements : [], eofToken, 0 /* None */);
|
|
sourceFile.fileName = getRelativePathFromDirectory(
|
|
host.getCurrentDirectory(),
|
|
getNormalizedAbsolutePath(fileName, buildInfoDirectory),
|
|
!host.useCaseSensitiveFileNames()
|
|
);
|
|
sourceFile.text = (_a3 = prologueInfo == null ? void 0 : prologueInfo.text) != null ? _a3 : "";
|
|
setTextRangePosWidth(sourceFile, 0, (_b = prologueInfo == null ? void 0 : prologueInfo.text.length) != null ? _b : 0);
|
|
setEachParent(sourceFile.statements, sourceFile);
|
|
setTextRangePosWidth(eofToken, sourceFile.end, 0);
|
|
setParent(eofToken, sourceFile);
|
|
return sourceFile;
|
|
});
|
|
}
|
|
function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitUsingBuildInfo", {}, true);
|
|
ts_performance_exports.mark("beforeEmit");
|
|
const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
|
|
ts_performance_exports.mark("afterEmit");
|
|
ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers) {
|
|
const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, false);
|
|
const buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
|
|
if (!buildInfo)
|
|
return buildInfoPath;
|
|
if (!buildInfo.bundle || !buildInfo.bundle.js || declarationFilePath && !buildInfo.bundle.dts)
|
|
return buildInfoPath;
|
|
const jsFileText = host.readFile(Debug.checkDefined(jsFilePath));
|
|
if (!jsFileText)
|
|
return jsFilePath;
|
|
if (computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash)
|
|
return jsFilePath;
|
|
const sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
|
|
if (sourceMapFilePath && !sourceMapText || config.options.inlineSourceMap)
|
|
return sourceMapFilePath || "inline sourcemap decoding";
|
|
if (sourceMapFilePath && computeSignature(sourceMapText, host) !== buildInfo.bundle.js.mapHash)
|
|
return sourceMapFilePath;
|
|
const declarationText = declarationFilePath && host.readFile(declarationFilePath);
|
|
if (declarationFilePath && !declarationText)
|
|
return declarationFilePath;
|
|
if (declarationFilePath && computeSignature(declarationText, host) !== buildInfo.bundle.dts.hash)
|
|
return declarationFilePath;
|
|
const declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
|
|
if (declarationMapPath && !declarationMapText || config.options.inlineSourceMap)
|
|
return declarationMapPath || "inline sourcemap decoding";
|
|
if (declarationMapPath && computeSignature(declarationMapText, host) !== buildInfo.bundle.dts.mapHash)
|
|
return declarationMapPath;
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const ownPrependInput = createInputFilesWithFileTexts(
|
|
jsFilePath,
|
|
jsFileText,
|
|
sourceMapFilePath,
|
|
sourceMapText,
|
|
declarationFilePath,
|
|
declarationText,
|
|
declarationMapPath,
|
|
declarationMapText,
|
|
buildInfoPath,
|
|
buildInfo,
|
|
true
|
|
);
|
|
const outputFiles = [];
|
|
const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f), host);
|
|
const sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
|
|
let changedDtsText;
|
|
let changedDtsData;
|
|
const emitHost = {
|
|
getPrependNodes: memoize(() => [...prependNodes, ownPrependInput]),
|
|
getCanonicalFileName: host.getCanonicalFileName,
|
|
getCommonSourceDirectory: () => getNormalizedAbsolutePath(buildInfo.bundle.commonSourceDirectory, buildInfoDirectory),
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
getNewLine: () => host.getNewLine(),
|
|
getSourceFile: returnUndefined,
|
|
getSourceFileByPath: returnUndefined,
|
|
getSourceFiles: () => sourceFilesForJsEmit,
|
|
getLibFileFromReference: notImplemented,
|
|
isSourceFileFromExternalLibrary: returnFalse,
|
|
getResolvedProjectReferenceToRedirect: returnUndefined,
|
|
getProjectReferenceRedirect: returnUndefined,
|
|
isSourceOfProjectReferenceRedirect: returnFalse,
|
|
writeFile: (name, text, writeByteOrderMark, _onError, _sourceFiles, data) => {
|
|
switch (name) {
|
|
case jsFilePath:
|
|
if (jsFileText === text)
|
|
return;
|
|
break;
|
|
case sourceMapFilePath:
|
|
if (sourceMapText === text)
|
|
return;
|
|
break;
|
|
case buildInfoPath:
|
|
break;
|
|
case declarationFilePath:
|
|
if (declarationText === text)
|
|
return;
|
|
changedDtsText = text;
|
|
changedDtsData = data;
|
|
break;
|
|
case declarationMapPath:
|
|
if (declarationMapText === text)
|
|
return;
|
|
break;
|
|
default:
|
|
Debug.fail(`Unexpected path: ${name}`);
|
|
}
|
|
outputFiles.push({ name, text, writeByteOrderMark, data });
|
|
},
|
|
isEmitBlocked: returnFalse,
|
|
readFile: (f) => host.readFile(f),
|
|
fileExists: (f) => host.fileExists(f),
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getBuildInfo: (bundle) => {
|
|
const program = buildInfo.program;
|
|
if (program && changedDtsText !== void 0 && config.options.composite) {
|
|
program.outSignature = computeSignature(changedDtsText, host, changedDtsData);
|
|
}
|
|
const { js, dts, sourceFiles } = buildInfo.bundle;
|
|
bundle.js.sources = js.sources;
|
|
if (dts) {
|
|
bundle.dts.sources = dts.sources;
|
|
}
|
|
bundle.sourceFiles = sourceFiles;
|
|
return createBuildInfo(program, bundle);
|
|
},
|
|
getSourceFileFromReference: returnUndefined,
|
|
redirectTargetsMap: createMultiMap(),
|
|
getFileIncludeReasons: notImplemented,
|
|
createHash: maybeBind(host, host.createHash)
|
|
};
|
|
emitFiles(
|
|
notImplementedResolver,
|
|
emitHost,
|
|
void 0,
|
|
getTransformers(config.options, customTransformers)
|
|
);
|
|
return outputFiles;
|
|
}
|
|
function createPrinter(printerOptions = {}, handlers = {}) {
|
|
const {
|
|
hasGlobalName,
|
|
onEmitNode = noEmitNotification,
|
|
isEmitNotificationEnabled,
|
|
substituteNode = noEmitSubstitution,
|
|
onBeforeEmitNode,
|
|
onAfterEmitNode,
|
|
onBeforeEmitNodeArray,
|
|
onAfterEmitNodeArray,
|
|
onBeforeEmitToken,
|
|
onAfterEmitToken
|
|
} = handlers;
|
|
const extendedDiagnostics = !!printerOptions.extendedDiagnostics;
|
|
const newLine = getNewLineCharacter(printerOptions);
|
|
const moduleKind = getEmitModuleKind(printerOptions);
|
|
const bundledHelpers = /* @__PURE__ */ new Map();
|
|
let currentSourceFile;
|
|
let nodeIdToGeneratedName;
|
|
let autoGeneratedIdToGeneratedName;
|
|
let generatedNames;
|
|
let formattedNameTempFlagsStack;
|
|
let formattedNameTempFlags;
|
|
let privateNameTempFlagsStack;
|
|
let privateNameTempFlags;
|
|
let tempFlagsStack;
|
|
let tempFlags;
|
|
let reservedNamesStack;
|
|
let reservedNames;
|
|
let preserveSourceNewlines = printerOptions.preserveSourceNewlines;
|
|
let nextListElementPos;
|
|
let writer;
|
|
let ownWriter;
|
|
let write = writeBase;
|
|
let isOwnFileEmit;
|
|
const bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
|
|
const relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
|
|
const recordInternalSection = printerOptions.recordInternalSection;
|
|
let sourceFileTextPos = 0;
|
|
let sourceFileTextKind = "text" /* Text */;
|
|
let sourceMapsDisabled = true;
|
|
let sourceMapGenerator;
|
|
let sourceMapSource;
|
|
let sourceMapSourceIndex = -1;
|
|
let mostRecentlyAddedSourceMapSource;
|
|
let mostRecentlyAddedSourceMapSourceIndex = -1;
|
|
let containerPos = -1;
|
|
let containerEnd = -1;
|
|
let declarationListContainerEnd = -1;
|
|
let currentLineMap;
|
|
let detachedCommentsInfo;
|
|
let hasWrittenComment = false;
|
|
let commentsDisabled = !!printerOptions.removeComments;
|
|
let lastSubstitution;
|
|
let currentParenthesizerRule;
|
|
const { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
|
|
const parenthesizer = factory.parenthesizer;
|
|
const typeArgumentParenthesizerRuleSelector = {
|
|
select: (index) => index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : void 0
|
|
};
|
|
const emitBinaryExpression = createEmitBinaryExpression();
|
|
reset();
|
|
return {
|
|
printNode,
|
|
printList,
|
|
printFile,
|
|
printBundle,
|
|
writeNode,
|
|
writeList,
|
|
writeFile: writeFile2,
|
|
writeBundle,
|
|
bundleFileInfo
|
|
};
|
|
function printNode(hint, node, sourceFile) {
|
|
switch (hint) {
|
|
case 0 /* SourceFile */:
|
|
Debug.assert(isSourceFile(node), "Expected a SourceFile node.");
|
|
break;
|
|
case 2 /* IdentifierName */:
|
|
Debug.assert(isIdentifier(node), "Expected an Identifier node.");
|
|
break;
|
|
case 1 /* Expression */:
|
|
Debug.assert(isExpression(node), "Expected an Expression node.");
|
|
break;
|
|
}
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
return printFile(node);
|
|
case 309 /* Bundle */:
|
|
return printBundle(node);
|
|
case 310 /* 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(), void 0);
|
|
return endPrint();
|
|
}
|
|
function printFile(sourceFile) {
|
|
writeFile2(sourceFile, beginPrint(), void 0);
|
|
return endPrint();
|
|
}
|
|
function printUnparsedSource(unparsed) {
|
|
writeUnparsedSource(unparsed, beginPrint());
|
|
return endPrint();
|
|
}
|
|
function writeNode(hint, node, sourceFile, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
print(hint, node, sourceFile);
|
|
reset();
|
|
writer = previousWriter;
|
|
}
|
|
function writeList(format, nodes, sourceFile, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
if (sourceFile) {
|
|
setSourceFile(sourceFile);
|
|
}
|
|
emitList(void 0, nodes, format);
|
|
reset();
|
|
writer = previousWriter;
|
|
}
|
|
function getTextPosWithWriteLine() {
|
|
return writer.getTextPosWithWriteLine ? writer.getTextPosWithWriteLine() : writer.getTextPos();
|
|
}
|
|
function updateOrPushBundleFileTextLike(pos, end, kind) {
|
|
const last2 = lastOrUndefined(bundleFileInfo.sections);
|
|
if (last2 && last2.kind === kind) {
|
|
last2.end = end;
|
|
} else {
|
|
bundleFileInfo.sections.push({ pos, end, kind });
|
|
}
|
|
}
|
|
function recordBundleFileInternalSectionStart(node) {
|
|
if (recordInternalSection && bundleFileInfo && currentSourceFile && (isDeclaration(node) || isVariableStatement(node)) && isInternalDeclaration(node, currentSourceFile) && sourceFileTextKind !== "internal" /* Internal */) {
|
|
const prevSourceFileTextKind = sourceFileTextKind;
|
|
recordBundleFileTextLikeSection(writer.getTextPos());
|
|
sourceFileTextPos = getTextPosWithWriteLine();
|
|
sourceFileTextKind = "internal" /* Internal */;
|
|
return prevSourceFileTextKind;
|
|
}
|
|
return void 0;
|
|
}
|
|
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, sourceMapGenerator2) {
|
|
isOwnFileEmit = false;
|
|
const previousWriter = writer;
|
|
setWriter(output, sourceMapGenerator2);
|
|
emitShebangIfNeeded(bundle);
|
|
emitPrologueDirectivesIfNeeded(bundle);
|
|
emitHelpers(bundle);
|
|
emitSyntheticTripleSlashReferencesIfNeeded(bundle);
|
|
for (const prepend of bundle.prepends) {
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
const savedSections = bundleFileInfo && bundleFileInfo.sections;
|
|
if (savedSections)
|
|
bundleFileInfo.sections = [];
|
|
print(4 /* Unspecified */, prepend, void 0);
|
|
if (bundleFileInfo) {
|
|
const newSections = bundleFileInfo.sections;
|
|
bundleFileInfo.sections = savedSections;
|
|
if (prepend.oldFileOfCurrentEmit)
|
|
bundleFileInfo.sections.push(...newSections);
|
|
else {
|
|
newSections.forEach((section) => Debug.assert(isBundleFileTextLike(section)));
|
|
bundleFileInfo.sections.push({
|
|
pos,
|
|
end: writer.getTextPos(),
|
|
kind: "prepend" /* Prepend */,
|
|
data: relativeToBuildInfo(prepend.fileName),
|
|
texts: newSections
|
|
});
|
|
}
|
|
}
|
|
}
|
|
sourceFileTextPos = getTextPosWithWriteLine();
|
|
for (const sourceFile of bundle.sourceFiles) {
|
|
print(0 /* SourceFile */, sourceFile, sourceFile);
|
|
}
|
|
if (bundleFileInfo && bundle.sourceFiles.length) {
|
|
const end = writer.getTextPos();
|
|
if (recordBundleFileTextLikeSection(end)) {
|
|
const prologues = getPrologueDirectivesFromBundledSourceFiles(bundle);
|
|
if (prologues) {
|
|
if (!bundleFileInfo.sources)
|
|
bundleFileInfo.sources = {};
|
|
bundleFileInfo.sources.prologues = prologues;
|
|
}
|
|
const helpers = getHelpersFromBundledSourceFiles(bundle);
|
|
if (helpers) {
|
|
if (!bundleFileInfo.sources)
|
|
bundleFileInfo.sources = {};
|
|
bundleFileInfo.sources.helpers = helpers;
|
|
}
|
|
}
|
|
}
|
|
reset();
|
|
writer = previousWriter;
|
|
}
|
|
function writeUnparsedSource(unparsed, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
print(4 /* Unspecified */, unparsed, void 0);
|
|
reset();
|
|
writer = previousWriter;
|
|
}
|
|
function writeFile2(sourceFile, output, sourceMapGenerator2) {
|
|
isOwnFileEmit = true;
|
|
const previousWriter = writer;
|
|
setWriter(output, sourceMapGenerator2);
|
|
emitShebangIfNeeded(sourceFile);
|
|
emitPrologueDirectivesIfNeeded(sourceFile);
|
|
print(0 /* SourceFile */, sourceFile, sourceFile);
|
|
reset();
|
|
writer = previousWriter;
|
|
}
|
|
function beginPrint() {
|
|
return ownWriter || (ownWriter = createTextWriter(newLine));
|
|
}
|
|
function endPrint() {
|
|
const text = ownWriter.getText();
|
|
ownWriter.clear();
|
|
return text;
|
|
}
|
|
function print(hint, node, sourceFile) {
|
|
if (sourceFile) {
|
|
setSourceFile(sourceFile);
|
|
}
|
|
pipelineEmit(hint, node, void 0);
|
|
}
|
|
function setSourceFile(sourceFile) {
|
|
currentSourceFile = sourceFile;
|
|
currentLineMap = void 0;
|
|
detachedCommentsInfo = void 0;
|
|
if (sourceFile) {
|
|
setSourceMapSource(sourceFile);
|
|
}
|
|
}
|
|
function setWriter(_writer, _sourceMapGenerator) {
|
|
if (_writer && printerOptions.omitTrailingSemicolon) {
|
|
_writer = getTrailingSemicolonDeferringWriter(_writer);
|
|
}
|
|
writer = _writer;
|
|
sourceMapGenerator = _sourceMapGenerator;
|
|
sourceMapsDisabled = !writer || !sourceMapGenerator;
|
|
}
|
|
function reset() {
|
|
nodeIdToGeneratedName = [];
|
|
autoGeneratedIdToGeneratedName = [];
|
|
generatedNames = /* @__PURE__ */ new Set();
|
|
formattedNameTempFlagsStack = [];
|
|
formattedNameTempFlags = /* @__PURE__ */ new Map();
|
|
privateNameTempFlagsStack = [];
|
|
privateNameTempFlags = TempFlags.Auto;
|
|
tempFlagsStack = [];
|
|
tempFlags = TempFlags.Auto;
|
|
reservedNamesStack = [];
|
|
currentSourceFile = void 0;
|
|
currentLineMap = void 0;
|
|
detachedCommentsInfo = void 0;
|
|
setWriter(void 0, void 0);
|
|
}
|
|
function getCurrentLineMap() {
|
|
return currentLineMap || (currentLineMap = getLineStarts(Debug.checkDefined(currentSourceFile)));
|
|
}
|
|
function emit(node, parenthesizerRule) {
|
|
if (node === void 0)
|
|
return;
|
|
const prevSourceFileTextKind = recordBundleFileInternalSectionStart(node);
|
|
pipelineEmit(4 /* Unspecified */, node, parenthesizerRule);
|
|
recordBundleFileInternalSectionEnd(prevSourceFileTextKind);
|
|
}
|
|
function emitIdentifierName(node) {
|
|
if (node === void 0)
|
|
return;
|
|
pipelineEmit(2 /* IdentifierName */, node, void 0);
|
|
}
|
|
function emitExpression(node, parenthesizerRule) {
|
|
if (node === void 0)
|
|
return;
|
|
pipelineEmit(1 /* Expression */, node, parenthesizerRule);
|
|
}
|
|
function emitJsxAttributeValue(node) {
|
|
pipelineEmit(isStringLiteral(node) ? 6 /* JsxAttributeValue */ : 4 /* Unspecified */, node);
|
|
}
|
|
function beforeEmitNode(node) {
|
|
if (preserveSourceNewlines && getEmitFlags(node) & 268435456 /* IgnoreSourceNewlines */) {
|
|
preserveSourceNewlines = false;
|
|
}
|
|
}
|
|
function afterEmitNode(savedPreserveSourceNewlines) {
|
|
preserveSourceNewlines = savedPreserveSourceNewlines;
|
|
}
|
|
function pipelineEmit(emitHint, node, parenthesizerRule) {
|
|
currentParenthesizerRule = parenthesizerRule;
|
|
const pipelinePhase = getPipelinePhase(0 /* Notification */, emitHint, node);
|
|
pipelinePhase(emitHint, node);
|
|
currentParenthesizerRule = void 0;
|
|
}
|
|
function shouldEmitComments(node) {
|
|
return !commentsDisabled && !isSourceFile(node);
|
|
}
|
|
function shouldEmitSourceMaps(node) {
|
|
return !sourceMapsDisabled && !isSourceFile(node) && !isInJsonFile(node) && !isUnparsedSource(node) && !isUnparsedPrepend(node);
|
|
}
|
|
function getPipelinePhase(phase, emitHint, node) {
|
|
switch (phase) {
|
|
case 0 /* Notification */:
|
|
if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) {
|
|
return pipelineEmitWithNotification;
|
|
}
|
|
case 1 /* Substitution */:
|
|
if (substituteNode !== noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) {
|
|
if (currentParenthesizerRule) {
|
|
lastSubstitution = currentParenthesizerRule(lastSubstitution);
|
|
}
|
|
return pipelineEmitWithSubstitution;
|
|
}
|
|
case 2 /* Comments */:
|
|
if (shouldEmitComments(node)) {
|
|
return pipelineEmitWithComments;
|
|
}
|
|
case 3 /* SourceMaps */:
|
|
if (shouldEmitSourceMaps(node)) {
|
|
return pipelineEmitWithSourceMaps;
|
|
}
|
|
case 4 /* Emit */:
|
|
return pipelineEmitWithHint;
|
|
default:
|
|
return Debug.assertNever(phase);
|
|
}
|
|
}
|
|
function getNextPipelinePhase(currentPhase, emitHint, node) {
|
|
return getPipelinePhase(currentPhase + 1, emitHint, node);
|
|
}
|
|
function pipelineEmitWithNotification(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(0 /* Notification */, hint, node);
|
|
onEmitNode(hint, node, pipelinePhase);
|
|
}
|
|
function pipelineEmitWithHint(hint, node) {
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(node);
|
|
if (preserveSourceNewlines) {
|
|
const savedPreserveSourceNewlines = preserveSourceNewlines;
|
|
beforeEmitNode(node);
|
|
pipelineEmitWithHintWorker(hint, node);
|
|
afterEmitNode(savedPreserveSourceNewlines);
|
|
} else {
|
|
pipelineEmitWithHintWorker(hint, node);
|
|
}
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(node);
|
|
currentParenthesizerRule = void 0;
|
|
}
|
|
function pipelineEmitWithHintWorker(hint, node, allowSnippets = true) {
|
|
if (allowSnippets) {
|
|
const snippet = getSnippetElement(node);
|
|
if (snippet) {
|
|
return emitSnippetNode(hint, node, snippet);
|
|
}
|
|
}
|
|
if (hint === 0 /* SourceFile */)
|
|
return emitSourceFile(cast(node, isSourceFile));
|
|
if (hint === 2 /* IdentifierName */)
|
|
return emitIdentifier(cast(node, isIdentifier));
|
|
if (hint === 6 /* JsxAttributeValue */)
|
|
return emitLiteral(cast(node, isStringLiteral), true);
|
|
if (hint === 3 /* MappedTypeParameter */)
|
|
return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
|
|
if (hint === 5 /* EmbeddedStatement */) {
|
|
Debug.assertNode(node, isEmptyStatement);
|
|
return emitEmptyStatement(true);
|
|
}
|
|
if (hint === 4 /* Unspecified */) {
|
|
switch (node.kind) {
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
return emitLiteral(node, false);
|
|
case 79 /* Identifier */:
|
|
return emitIdentifier(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return emitPrivateIdentifier(node);
|
|
case 163 /* QualifiedName */:
|
|
return emitQualifiedName(node);
|
|
case 164 /* ComputedPropertyName */:
|
|
return emitComputedPropertyName(node);
|
|
case 165 /* TypeParameter */:
|
|
return emitTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return emitParameter(node);
|
|
case 167 /* Decorator */:
|
|
return emitDecorator(node);
|
|
case 168 /* PropertySignature */:
|
|
return emitPropertySignature(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return emitPropertyDeclaration(node);
|
|
case 170 /* MethodSignature */:
|
|
return emitMethodSignature(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return emitMethodDeclaration(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return emitClassStaticBlockDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return emitConstructor(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return emitAccessorDeclaration(node);
|
|
case 176 /* CallSignature */:
|
|
return emitCallSignature(node);
|
|
case 177 /* ConstructSignature */:
|
|
return emitConstructSignature(node);
|
|
case 178 /* IndexSignature */:
|
|
return emitIndexSignature(node);
|
|
case 179 /* TypePredicate */:
|
|
return emitTypePredicate(node);
|
|
case 180 /* TypeReference */:
|
|
return emitTypeReference(node);
|
|
case 181 /* FunctionType */:
|
|
return emitFunctionType(node);
|
|
case 182 /* ConstructorType */:
|
|
return emitConstructorType(node);
|
|
case 183 /* TypeQuery */:
|
|
return emitTypeQuery(node);
|
|
case 184 /* TypeLiteral */:
|
|
return emitTypeLiteral(node);
|
|
case 185 /* ArrayType */:
|
|
return emitArrayType(node);
|
|
case 186 /* TupleType */:
|
|
return emitTupleType(node);
|
|
case 187 /* OptionalType */:
|
|
return emitOptionalType(node);
|
|
case 189 /* UnionType */:
|
|
return emitUnionType(node);
|
|
case 190 /* IntersectionType */:
|
|
return emitIntersectionType(node);
|
|
case 191 /* ConditionalType */:
|
|
return emitConditionalType(node);
|
|
case 192 /* InferType */:
|
|
return emitInferType(node);
|
|
case 193 /* ParenthesizedType */:
|
|
return emitParenthesizedType(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return emitExpressionWithTypeArguments(node);
|
|
case 194 /* ThisType */:
|
|
return emitThisType();
|
|
case 195 /* TypeOperator */:
|
|
return emitTypeOperator(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return emitIndexedAccessType(node);
|
|
case 197 /* MappedType */:
|
|
return emitMappedType(node);
|
|
case 198 /* LiteralType */:
|
|
return emitLiteralType(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return emitNamedTupleMember(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return emitTemplateType(node);
|
|
case 201 /* TemplateLiteralTypeSpan */:
|
|
return emitTemplateTypeSpan(node);
|
|
case 202 /* ImportType */:
|
|
return emitImportTypeNode(node);
|
|
case 203 /* ObjectBindingPattern */:
|
|
return emitObjectBindingPattern(node);
|
|
case 204 /* ArrayBindingPattern */:
|
|
return emitArrayBindingPattern(node);
|
|
case 205 /* BindingElement */:
|
|
return emitBindingElement(node);
|
|
case 236 /* TemplateSpan */:
|
|
return emitTemplateSpan(node);
|
|
case 237 /* SemicolonClassElement */:
|
|
return emitSemicolonClassElement();
|
|
case 238 /* Block */:
|
|
return emitBlock(node);
|
|
case 240 /* VariableStatement */:
|
|
return emitVariableStatement(node);
|
|
case 239 /* EmptyStatement */:
|
|
return emitEmptyStatement(false);
|
|
case 241 /* ExpressionStatement */:
|
|
return emitExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return emitIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return emitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return emitWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return emitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return emitForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return emitForOfStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return emitContinueStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return emitBreakStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return emitReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return emitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return emitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return emitLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return emitThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return emitTryStatement(node);
|
|
case 256 /* DebuggerStatement */:
|
|
return emitDebuggerStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return emitVariableDeclaration(node);
|
|
case 258 /* VariableDeclarationList */:
|
|
return emitVariableDeclarationList(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return emitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return emitClassDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return emitInterfaceDeclaration(node);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return emitTypeAliasDeclaration(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return emitEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return emitModuleDeclaration(node);
|
|
case 265 /* ModuleBlock */:
|
|
return emitModuleBlock(node);
|
|
case 266 /* CaseBlock */:
|
|
return emitCaseBlock(node);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return emitNamespaceExportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return emitImportEqualsDeclaration(node);
|
|
case 269 /* ImportDeclaration */:
|
|
return emitImportDeclaration(node);
|
|
case 270 /* ImportClause */:
|
|
return emitImportClause(node);
|
|
case 271 /* NamespaceImport */:
|
|
return emitNamespaceImport(node);
|
|
case 277 /* NamespaceExport */:
|
|
return emitNamespaceExport(node);
|
|
case 272 /* NamedImports */:
|
|
return emitNamedImports(node);
|
|
case 273 /* ImportSpecifier */:
|
|
return emitImportSpecifier(node);
|
|
case 274 /* ExportAssignment */:
|
|
return emitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return emitExportDeclaration(node);
|
|
case 276 /* NamedExports */:
|
|
return emitNamedExports(node);
|
|
case 278 /* ExportSpecifier */:
|
|
return emitExportSpecifier(node);
|
|
case 296 /* AssertClause */:
|
|
return emitAssertClause(node);
|
|
case 297 /* AssertEntry */:
|
|
return emitAssertEntry(node);
|
|
case 279 /* MissingDeclaration */:
|
|
return;
|
|
case 280 /* ExternalModuleReference */:
|
|
return emitExternalModuleReference(node);
|
|
case 11 /* JsxText */:
|
|
return emitJsxText(node);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 286 /* JsxOpeningFragment */:
|
|
return emitJsxOpeningElementOrFragment(node);
|
|
case 284 /* JsxClosingElement */:
|
|
case 287 /* JsxClosingFragment */:
|
|
return emitJsxClosingElementOrFragment(node);
|
|
case 288 /* JsxAttribute */:
|
|
return emitJsxAttribute(node);
|
|
case 289 /* JsxAttributes */:
|
|
return emitJsxAttributes(node);
|
|
case 290 /* JsxSpreadAttribute */:
|
|
return emitJsxSpreadAttribute(node);
|
|
case 291 /* JsxExpression */:
|
|
return emitJsxExpression(node);
|
|
case 292 /* CaseClause */:
|
|
return emitCaseClause(node);
|
|
case 293 /* DefaultClause */:
|
|
return emitDefaultClause(node);
|
|
case 294 /* HeritageClause */:
|
|
return emitHeritageClause(node);
|
|
case 295 /* CatchClause */:
|
|
return emitCatchClause(node);
|
|
case 299 /* PropertyAssignment */:
|
|
return emitPropertyAssignment(node);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return emitShorthandPropertyAssignment(node);
|
|
case 301 /* SpreadAssignment */:
|
|
return emitSpreadAssignment(node);
|
|
case 302 /* EnumMember */:
|
|
return emitEnumMember(node);
|
|
case 303 /* UnparsedPrologue */:
|
|
return writeUnparsedNode(node);
|
|
case 310 /* UnparsedSource */:
|
|
case 304 /* UnparsedPrepend */:
|
|
return emitUnparsedSourceOrPrepend(node);
|
|
case 305 /* UnparsedText */:
|
|
case 306 /* UnparsedInternalText */:
|
|
return emitUnparsedTextLike(node);
|
|
case 307 /* UnparsedSyntheticReference */:
|
|
return emitUnparsedSyntheticReference(node);
|
|
case 308 /* SourceFile */:
|
|
return emitSourceFile(node);
|
|
case 309 /* Bundle */:
|
|
return Debug.fail("Bundles should be printed using printBundle");
|
|
case 311 /* InputFiles */:
|
|
return Debug.fail("InputFiles should not be printed");
|
|
case 312 /* JSDocTypeExpression */:
|
|
return emitJSDocTypeExpression(node);
|
|
case 313 /* JSDocNameReference */:
|
|
return emitJSDocNameReference(node);
|
|
case 315 /* JSDocAllType */:
|
|
return writePunctuation("*");
|
|
case 316 /* JSDocUnknownType */:
|
|
return writePunctuation("?");
|
|
case 317 /* JSDocNullableType */:
|
|
return emitJSDocNullableType(node);
|
|
case 318 /* JSDocNonNullableType */:
|
|
return emitJSDocNonNullableType(node);
|
|
case 319 /* JSDocOptionalType */:
|
|
return emitJSDocOptionalType(node);
|
|
case 320 /* JSDocFunctionType */:
|
|
return emitJSDocFunctionType(node);
|
|
case 188 /* RestType */:
|
|
case 321 /* JSDocVariadicType */:
|
|
return emitRestOrJSDocVariadicType(node);
|
|
case 322 /* JSDocNamepathType */:
|
|
return;
|
|
case 323 /* JSDoc */:
|
|
return emitJSDoc(node);
|
|
case 325 /* JSDocTypeLiteral */:
|
|
return emitJSDocTypeLiteral(node);
|
|
case 326 /* JSDocSignature */:
|
|
return emitJSDocSignature(node);
|
|
case 330 /* JSDocTag */:
|
|
case 335 /* JSDocClassTag */:
|
|
case 340 /* JSDocOverrideTag */:
|
|
return emitJSDocSimpleTag(node);
|
|
case 331 /* JSDocAugmentsTag */:
|
|
case 332 /* JSDocImplementsTag */:
|
|
return emitJSDocHeritageTag(node);
|
|
case 333 /* JSDocAuthorTag */:
|
|
case 334 /* JSDocDeprecatedTag */:
|
|
return;
|
|
case 336 /* JSDocPublicTag */:
|
|
case 337 /* JSDocPrivateTag */:
|
|
case 338 /* JSDocProtectedTag */:
|
|
case 339 /* JSDocReadonlyTag */:
|
|
return;
|
|
case 341 /* JSDocCallbackTag */:
|
|
return emitJSDocCallbackTag(node);
|
|
case 343 /* JSDocParameterTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
return emitJSDocPropertyLikeTag(node);
|
|
case 342 /* JSDocEnumTag */:
|
|
case 344 /* JSDocReturnTag */:
|
|
case 345 /* JSDocThisTag */:
|
|
case 346 /* JSDocTypeTag */:
|
|
return emitJSDocSimpleTypedTag(node);
|
|
case 347 /* JSDocTemplateTag */:
|
|
return emitJSDocTemplateTag(node);
|
|
case 348 /* JSDocTypedefTag */:
|
|
return emitJSDocTypedefTag(node);
|
|
case 349 /* JSDocSeeTag */:
|
|
return emitJSDocSeeTag(node);
|
|
case 352 /* NotEmittedStatement */:
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return;
|
|
}
|
|
if (isExpression(node)) {
|
|
hint = 1 /* Expression */;
|
|
if (substituteNode !== noEmitSubstitution) {
|
|
const substitute = substituteNode(hint, node) || node;
|
|
if (substitute !== node) {
|
|
node = substitute;
|
|
if (currentParenthesizerRule) {
|
|
node = currentParenthesizerRule(node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
switch (node.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return emitNumericOrBigIntLiteral(node);
|
|
case 10 /* StringLiteral */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return emitLiteral(node, false);
|
|
case 79 /* Identifier */:
|
|
return emitIdentifier(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return emitPrivateIdentifier(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return emitArrayLiteralExpression(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return emitObjectLiteralExpression(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return emitPropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return emitElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return emitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return emitNewExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return emitTaggedTemplateExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
return emitTypeAssertionExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return emitParenthesizedExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
return emitFunctionExpression(node);
|
|
case 216 /* ArrowFunction */:
|
|
return emitArrowFunction(node);
|
|
case 217 /* DeleteExpression */:
|
|
return emitDeleteExpression(node);
|
|
case 218 /* TypeOfExpression */:
|
|
return emitTypeOfExpression(node);
|
|
case 219 /* VoidExpression */:
|
|
return emitVoidExpression(node);
|
|
case 220 /* AwaitExpression */:
|
|
return emitAwaitExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return emitPrefixUnaryExpression(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return emitPostfixUnaryExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return emitBinaryExpression(node);
|
|
case 224 /* ConditionalExpression */:
|
|
return emitConditionalExpression(node);
|
|
case 225 /* TemplateExpression */:
|
|
return emitTemplateExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return emitYieldExpression(node);
|
|
case 227 /* SpreadElement */:
|
|
return emitSpreadElement(node);
|
|
case 228 /* ClassExpression */:
|
|
return emitClassExpression(node);
|
|
case 229 /* OmittedExpression */:
|
|
return;
|
|
case 231 /* AsExpression */:
|
|
return emitAsExpression(node);
|
|
case 232 /* NonNullExpression */:
|
|
return emitNonNullExpression(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return emitExpressionWithTypeArguments(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return emitSatisfiesExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return emitMetaProperty(node);
|
|
case 234 /* SyntheticExpression */:
|
|
return Debug.fail("SyntheticExpression should never be printed.");
|
|
case 281 /* JsxElement */:
|
|
return emitJsxElement(node);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return emitJsxSelfClosingElement(node);
|
|
case 285 /* JsxFragment */:
|
|
return emitJsxFragment(node);
|
|
case 351 /* SyntaxList */:
|
|
return Debug.fail("SyntaxList should not be printed");
|
|
case 352 /* NotEmittedStatement */:
|
|
return;
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return emitPartiallyEmittedExpression(node);
|
|
case 354 /* CommaListExpression */:
|
|
return emitCommaList(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return;
|
|
case 357 /* SyntheticReferenceExpression */:
|
|
return Debug.fail("SyntheticReferenceExpression should not be printed");
|
|
}
|
|
}
|
|
if (isKeyword(node.kind))
|
|
return writeTokenNode(node, writeKeyword);
|
|
if (isTokenKind(node.kind))
|
|
return writeTokenNode(node, writePunctuation);
|
|
Debug.fail(`Unhandled SyntaxKind: ${Debug.formatSyntaxKind(node.kind)}.`);
|
|
}
|
|
function emitMappedTypeParameter(node) {
|
|
emit(node.name);
|
|
writeSpace();
|
|
writeKeyword("in");
|
|
writeSpace();
|
|
emit(node.constraint);
|
|
}
|
|
function pipelineEmitWithSubstitution(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(1 /* Substitution */, hint, node);
|
|
Debug.assertIsDefined(lastSubstitution);
|
|
node = lastSubstitution;
|
|
lastSubstitution = void 0;
|
|
pipelinePhase(hint, node);
|
|
}
|
|
function getHelpersFromBundledSourceFiles(bundle) {
|
|
let result;
|
|
if (moduleKind === 0 /* None */ || printerOptions.noEmitHelpers) {
|
|
return void 0;
|
|
}
|
|
const bundledHelpers2 = /* @__PURE__ */ new Map();
|
|
for (const sourceFile of bundle.sourceFiles) {
|
|
const shouldSkip = getExternalHelpersModuleName(sourceFile) !== void 0;
|
|
const helpers = getSortedEmitHelpers(sourceFile);
|
|
if (!helpers)
|
|
continue;
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped && !shouldSkip && !bundledHelpers2.get(helper.name)) {
|
|
bundledHelpers2.set(helper.name, true);
|
|
(result || (result = [])).push(helper.name);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function emitHelpers(node) {
|
|
let helpersEmitted = false;
|
|
const bundle = node.kind === 309 /* Bundle */ ? node : void 0;
|
|
if (bundle && moduleKind === 0 /* None */) {
|
|
return;
|
|
}
|
|
const numPrepends = bundle ? bundle.prepends.length : 0;
|
|
const numNodes = bundle ? bundle.sourceFiles.length + numPrepends : 1;
|
|
for (let i = 0; i < numNodes; i++) {
|
|
const currentNode = bundle ? i < numPrepends ? bundle.prepends[i] : bundle.sourceFiles[i - numPrepends] : node;
|
|
const sourceFile = isSourceFile(currentNode) ? currentNode : isUnparsedSource(currentNode) ? void 0 : currentSourceFile;
|
|
const shouldSkip = printerOptions.noEmitHelpers || !!sourceFile && hasRecordedExternalHelpers(sourceFile);
|
|
const shouldBundle = (isSourceFile(currentNode) || isUnparsedSource(currentNode)) && !isOwnFileEmit;
|
|
const helpers = isUnparsedSource(currentNode) ? currentNode.helpers : getSortedEmitHelpers(currentNode);
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
if (shouldSkip)
|
|
continue;
|
|
if (shouldBundle) {
|
|
if (bundledHelpers.get(helper.name)) {
|
|
continue;
|
|
}
|
|
bundledHelpers.set(helper.name, true);
|
|
}
|
|
} else if (bundle) {
|
|
continue;
|
|
}
|
|
const pos = getTextPosWithWriteLine();
|
|
if (typeof helper.text === "string") {
|
|
writeLines(helper.text);
|
|
} else {
|
|
writeLines(helper.text(makeFileLevelOptimisticUniqueName));
|
|
}
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "emitHelpers" /* EmitHelpers */, data: helper.name });
|
|
helpersEmitted = true;
|
|
}
|
|
}
|
|
}
|
|
return helpersEmitted;
|
|
}
|
|
function getSortedEmitHelpers(node) {
|
|
const helpers = getEmitHelpers(node);
|
|
return helpers && stableSort(helpers, compareEmitHelpers);
|
|
}
|
|
function emitNumericOrBigIntLiteral(node) {
|
|
emitLiteral(node, false);
|
|
}
|
|
function emitLiteral(node, jsxAttributeEscape) {
|
|
const text = getLiteralTextOfNode(node, printerOptions.neverAsciiEscape, jsxAttributeEscape);
|
|
if ((printerOptions.sourceMap || printerOptions.inlineSourceMap) && (node.kind === 10 /* StringLiteral */ || isTemplateLiteralKind(node.kind))) {
|
|
writeLiteral(text);
|
|
} else {
|
|
writeStringLiteral(text);
|
|
}
|
|
}
|
|
function emitUnparsedSourceOrPrepend(unparsed) {
|
|
for (const text of unparsed.texts) {
|
|
writeLine();
|
|
emit(text);
|
|
}
|
|
}
|
|
function writeUnparsedNode(unparsed) {
|
|
writer.rawWrite(unparsed.parent.text.substring(unparsed.pos, unparsed.end));
|
|
}
|
|
function emitUnparsedTextLike(unparsed) {
|
|
const pos = getTextPosWithWriteLine();
|
|
writeUnparsedNode(unparsed);
|
|
if (bundleFileInfo) {
|
|
updateOrPushBundleFileTextLike(
|
|
pos,
|
|
writer.getTextPos(),
|
|
unparsed.kind === 305 /* UnparsedText */ ? "text" /* Text */ : "internal" /* Internal */
|
|
);
|
|
}
|
|
}
|
|
function emitUnparsedSyntheticReference(unparsed) {
|
|
const pos = getTextPosWithWriteLine();
|
|
writeUnparsedNode(unparsed);
|
|
if (bundleFileInfo) {
|
|
const section = clone(unparsed.section);
|
|
section.pos = pos;
|
|
section.end = writer.getTextPos();
|
|
bundleFileInfo.sections.push(section);
|
|
}
|
|
}
|
|
function emitSnippetNode(hint, node, snippet) {
|
|
switch (snippet.kind) {
|
|
case 1 /* Placeholder */:
|
|
emitPlaceholder(hint, node, snippet);
|
|
break;
|
|
case 0 /* TabStop */:
|
|
emitTabStop(hint, node, snippet);
|
|
break;
|
|
}
|
|
}
|
|
function emitPlaceholder(hint, node, snippet) {
|
|
nonEscapingWrite(`\${${snippet.order}:`);
|
|
pipelineEmitWithHintWorker(hint, node, false);
|
|
nonEscapingWrite(`}`);
|
|
}
|
|
function emitTabStop(hint, node, snippet) {
|
|
Debug.assert(
|
|
node.kind === 239 /* EmptyStatement */,
|
|
`A tab stop cannot be attached to a node of kind ${Debug.formatSyntaxKind(node.kind)}.`
|
|
);
|
|
Debug.assert(
|
|
hint !== 5 /* EmbeddedStatement */,
|
|
`A tab stop cannot be attached to an embedded statement.`
|
|
);
|
|
nonEscapingWrite(`$${snippet.order}`);
|
|
}
|
|
function emitIdentifier(node) {
|
|
const writeText = node.symbol ? writeSymbol : write;
|
|
writeText(getTextOfNode2(node, false), node.symbol);
|
|
emitList(node, node.typeArguments, 53776 /* TypeParameters */);
|
|
}
|
|
function emitPrivateIdentifier(node) {
|
|
const writeText = node.symbol ? writeSymbol : write;
|
|
writeText(getTextOfNode2(node, false), node.symbol);
|
|
}
|
|
function emitQualifiedName(node) {
|
|
emitEntityName(node.left);
|
|
writePunctuation(".");
|
|
emit(node.right);
|
|
}
|
|
function emitEntityName(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitComputedPropertyName(node) {
|
|
writePunctuation("[");
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName);
|
|
writePunctuation("]");
|
|
}
|
|
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 /* JSDocFunctionType */ && !node.name) {
|
|
emit(node.type);
|
|
} else {
|
|
emitTypeAnnotation(node.type);
|
|
}
|
|
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);
|
|
}
|
|
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 /* 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();
|
|
}
|
|
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("{");
|
|
const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineTypeLiteralMembers */ : 32897 /* MultiLineTypeLiteralMembers */;
|
|
emitList(node, node.members, flags | 524288 /* NoSpaceIfEmpty */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitArrayType(node) {
|
|
emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
|
|
writePunctuation("[");
|
|
writePunctuation("]");
|
|
}
|
|
function emitRestOrJSDocVariadicType(node) {
|
|
writePunctuation("...");
|
|
emit(node.type);
|
|
}
|
|
function emitTupleType(node) {
|
|
emitTokenWithComment(22 /* OpenBracketToken */, node.pos, writePunctuation, node);
|
|
const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 528 /* SingleLineTupleTypeElements */ : 657 /* MultiLineTupleTypeElements */;
|
|
emitList(node, node.elements, flags | 524288 /* NoSpaceIfEmpty */, parenthesizer.parenthesizeElementTypeOfTupleType);
|
|
emitTokenWithComment(23 /* CloseBracketToken */, node.elements.end, writePunctuation, node);
|
|
}
|
|
function emitNamedTupleMember(node) {
|
|
emit(node.dotDotDotToken);
|
|
emit(node.name);
|
|
emit(node.questionToken);
|
|
emitTokenWithComment(58 /* 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 /* UnionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfUnionType);
|
|
}
|
|
function emitIntersectionType(node) {
|
|
emitList(node, node.types, 520 /* 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();
|
|
const parenthesizerRule = node.operator === 146 /* 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) {
|
|
const emitFlags = getEmitFlags(node);
|
|
writePunctuation("{");
|
|
if (emitFlags & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else {
|
|
writeLine();
|
|
increaseIndent();
|
|
}
|
|
if (node.readonlyToken) {
|
|
emit(node.readonlyToken);
|
|
if (node.readonlyToken.kind !== 146 /* ReadonlyKeyword */) {
|
|
writeKeyword("readonly");
|
|
}
|
|
writeSpace();
|
|
}
|
|
writePunctuation("[");
|
|
pipelineEmit(3 /* 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 /* QuestionToken */) {
|
|
writePunctuation("?");
|
|
}
|
|
}
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
emit(node.type);
|
|
writeTrailingSemicolon();
|
|
if (emitFlags & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else {
|
|
writeLine();
|
|
decreaseIndent();
|
|
}
|
|
emitList(node, node.members, 2 /* PreserveLines */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitLiteralType(node) {
|
|
emitExpression(node.literal);
|
|
}
|
|
function emitTemplateType(node) {
|
|
emit(node.head);
|
|
emitList(node, node.templateSpans, 262144 /* 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();
|
|
const elements = node.assertions.assertClause.elements;
|
|
emitList(node.assertions.assertClause, elements, 526226 /* ImportClauseEntries */);
|
|
writeSpace();
|
|
writePunctuation("}");
|
|
}
|
|
writePunctuation(")");
|
|
if (node.qualifier) {
|
|
writePunctuation(".");
|
|
emit(node.qualifier);
|
|
}
|
|
emitTypeArguments(node, node.typeArguments);
|
|
}
|
|
function emitObjectBindingPattern(node) {
|
|
writePunctuation("{");
|
|
emitList(node, node.elements, 525136 /* ObjectBindingPatternElements */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitArrayBindingPattern(node) {
|
|
writePunctuation("[");
|
|
emitList(node, node.elements, 524880 /* 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);
|
|
}
|
|
function emitArrayLiteralExpression(node) {
|
|
const elements = node.elements;
|
|
const preferNewLine = node.multiLine ? 65536 /* PreferNewLine */ : 0 /* None */;
|
|
emitExpressionList(node, elements, 8914 /* ArrayLiteralExpressionElements */ | preferNewLine, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitObjectLiteralExpression(node) {
|
|
forEach(node.properties, generateMemberNames);
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
const preferNewLine = node.multiLine ? 65536 /* PreferNewLine */ : 0 /* None */;
|
|
const allowTrailingComma = currentSourceFile && currentSourceFile.languageVersion >= 1 /* ES5 */ && !isJsonSourceFile(currentSourceFile) ? 64 /* AllowTrailingComma */ : 0 /* None */;
|
|
emitList(node, node.properties, 526226 /* ObjectLiteralExpressionProperties */ | allowTrailingComma | preferNewLine);
|
|
if (indentedFlag) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function emitPropertyAccessExpression(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
const token = node.questionDotToken || setTextRangePosEnd(factory.createToken(24 /* DotToken */), node.expression.end, node.name.pos);
|
|
const linesBeforeDot = getLinesBetweenNodes(node, node.expression, token);
|
|
const linesAfterDot = getLinesBetweenNodes(node, token, node.name);
|
|
writeLinesAndIndent(linesBeforeDot, false);
|
|
const shouldEmitDotDot = token.kind !== 28 /* 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, false);
|
|
emit(node.name);
|
|
decreaseIndentIf(linesBeforeDot, linesAfterDot);
|
|
}
|
|
function mayNeedDotDotForPropertyAccess(expression) {
|
|
expression = skipPartiallyEmittedExpressions(expression);
|
|
if (isNumericLiteral(expression)) {
|
|
const text = getLiteralTextOfNode(expression, true, false);
|
|
return !expression.numericLiteralFlags && !stringContains(text, tokenToString(24 /* DotToken */));
|
|
} else if (isAccessExpression(expression)) {
|
|
const constantValue = getConstantValue(expression);
|
|
return typeof constantValue === "number" && isFinite(constantValue) && Math.floor(constantValue) === constantValue;
|
|
}
|
|
}
|
|
function emitElementAccessExpression(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
emit(node.questionDotToken);
|
|
emitTokenWithComment(22 /* OpenBracketToken */, node.expression.end, writePunctuation, node);
|
|
emitExpression(node.argumentExpression);
|
|
emitTokenWithComment(23 /* CloseBracketToken */, node.argumentExpression.end, writePunctuation, node);
|
|
}
|
|
function emitCallExpression(node) {
|
|
const indirectCall = getEmitFlags(node) & 1073741824 /* 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 /* CallExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitNewExpression(node) {
|
|
emitTokenWithComment(103 /* NewKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfNew);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
emitExpressionList(node, node.arguments, 18960 /* NewExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitTaggedTemplateExpression(node) {
|
|
const indirectCall = getEmitFlags(node) & 1073741824 /* 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) {
|
|
const openParenPos = emitTokenWithComment(20 /* OpenParenToken */, node.pos, writePunctuation, node);
|
|
const indented = writeLineSeparatorsAndIndentBefore(node.expression, node);
|
|
emitExpression(node.expression, void 0);
|
|
writeLineSeparatorsAfter(node.expression, node);
|
|
decreaseIndentIf(indented);
|
|
emitTokenWithComment(21 /* 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 /* DeleteKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitTypeOfExpression(node) {
|
|
emitTokenWithComment(112 /* TypeOfKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitVoidExpression(node) {
|
|
emitTokenWithComment(114 /* VoidKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitAwaitExpression(node) {
|
|
emitTokenWithComment(133 /* 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) {
|
|
const operand = node.operand;
|
|
return operand.kind === 221 /* PrefixUnaryExpression */ && (node.operator === 39 /* PlusToken */ && (operand.operator === 39 /* PlusToken */ || operand.operator === 45 /* PlusPlusToken */) || node.operator === 40 /* MinusToken */ && (operand.operator === 40 /* MinusToken */ || operand.operator === 46 /* MinusMinusToken */));
|
|
}
|
|
function emitPostfixUnaryExpression(node) {
|
|
emitExpression(node.operand, parenthesizer.parenthesizeOperandOfPostfixUnary);
|
|
writeTokenText(node.operator, writeOperator);
|
|
}
|
|
function createEmitBinaryExpression() {
|
|
return createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, void 0);
|
|
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;
|
|
const emitComments2 = state.shouldEmitCommentsStack[state.stackIndex] = shouldEmitComments(node);
|
|
const emitSourceMaps = state.shouldEmitSourceMapsStack[state.stackIndex] = shouldEmitSourceMaps(node);
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(node);
|
|
if (emitComments2)
|
|
emitCommentsBeforeNode(node);
|
|
if (emitSourceMaps)
|
|
emitSourceMapsBeforeNode(node);
|
|
beforeEmitNode(node);
|
|
} else {
|
|
state = {
|
|
stackIndex: 0,
|
|
preserveSourceNewlinesStack: [void 0],
|
|
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) {
|
|
const isCommaOperator = operatorToken.kind !== 27 /* CommaToken */;
|
|
const linesBeforeOperator = getLinesBetweenNodes(node, node.left, operatorToken);
|
|
const linesAfterOperator = getLinesBetweenNodes(node, operatorToken, node.right);
|
|
writeLinesAndIndent(linesBeforeOperator, isCommaOperator);
|
|
emitLeadingCommentsOfPosition(operatorToken.pos);
|
|
writeTokenNode(operatorToken, operatorToken.kind === 101 /* InKeyword */ ? writeKeyword : writeOperator);
|
|
emitTrailingCommentsOfPosition(operatorToken.end, true);
|
|
writeLinesAndIndent(linesAfterOperator, true);
|
|
}
|
|
function onRight(next, _workArea, parent) {
|
|
return maybeEmitExpression(next, parent, "right");
|
|
}
|
|
function onExit(node, state) {
|
|
const linesBeforeOperator = getLinesBetweenNodes(node, node.left, node.operatorToken);
|
|
const linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right);
|
|
decreaseIndentIf(linesBeforeOperator, linesAfterOperator);
|
|
if (state.stackIndex > 0) {
|
|
const savedPreserveSourceNewlines = state.preserveSourceNewlinesStack[state.stackIndex];
|
|
const savedContainerPos = state.containerPosStack[state.stackIndex];
|
|
const savedContainerEnd = state.containerEndStack[state.stackIndex];
|
|
const savedDeclarationListContainerEnd = state.declarationListContainerEndStack[state.stackIndex];
|
|
const shouldEmitComments2 = state.shouldEmitCommentsStack[state.stackIndex];
|
|
const shouldEmitSourceMaps2 = state.shouldEmitSourceMapsStack[state.stackIndex];
|
|
afterEmitNode(savedPreserveSourceNewlines);
|
|
if (shouldEmitSourceMaps2)
|
|
emitSourceMapsAfterNode(node);
|
|
if (shouldEmitComments2)
|
|
emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(node);
|
|
state.stackIndex--;
|
|
}
|
|
}
|
|
function maybeEmitExpression(next, parent, side) {
|
|
const parenthesizerRule = side === "left" ? parenthesizer.getParenthesizeLeftSideOfBinaryForOperator(parent.operatorToken.kind) : parenthesizer.getParenthesizeRightSideOfBinaryForOperator(parent.operatorToken.kind);
|
|
let pipelinePhase = getPipelinePhase(0 /* Notification */, 1 /* Expression */, next);
|
|
if (pipelinePhase === pipelineEmitWithSubstitution) {
|
|
Debug.assertIsDefined(lastSubstitution);
|
|
next = parenthesizerRule(cast(lastSubstitution, isExpression));
|
|
pipelinePhase = getNextPipelinePhase(1 /* Substitution */, 1 /* Expression */, next);
|
|
lastSubstitution = void 0;
|
|
}
|
|
if (pipelinePhase === pipelineEmitWithComments || pipelinePhase === pipelineEmitWithSourceMaps || pipelinePhase === pipelineEmitWithHint) {
|
|
if (isBinaryExpression(next)) {
|
|
return next;
|
|
}
|
|
}
|
|
currentParenthesizerRule = parenthesizerRule;
|
|
pipelinePhase(1 /* Expression */, next);
|
|
}
|
|
}
|
|
function emitConditionalExpression(node) {
|
|
const linesBeforeQuestion = getLinesBetweenNodes(node, node.condition, node.questionToken);
|
|
const linesAfterQuestion = getLinesBetweenNodes(node, node.questionToken, node.whenTrue);
|
|
const linesBeforeColon = getLinesBetweenNodes(node, node.whenTrue, node.colonToken);
|
|
const linesAfterColon = getLinesBetweenNodes(node, node.colonToken, node.whenFalse);
|
|
emitExpression(node.condition, parenthesizer.parenthesizeConditionOfConditionalExpression);
|
|
writeLinesAndIndent(linesBeforeQuestion, true);
|
|
emit(node.questionToken);
|
|
writeLinesAndIndent(linesAfterQuestion, true);
|
|
emitExpression(node.whenTrue, parenthesizer.parenthesizeBranchOfConditionalExpression);
|
|
decreaseIndentIf(linesBeforeQuestion, linesAfterQuestion);
|
|
writeLinesAndIndent(linesBeforeColon, true);
|
|
emit(node.colonToken);
|
|
writeLinesAndIndent(linesAfterColon, true);
|
|
emitExpression(node.whenFalse, parenthesizer.parenthesizeBranchOfConditionalExpression);
|
|
decreaseIndentIf(linesBeforeColon, linesAfterColon);
|
|
}
|
|
function emitTemplateExpression(node) {
|
|
emit(node.head);
|
|
emitList(node, node.templateSpans, 262144 /* TemplateExpressionSpans */);
|
|
}
|
|
function emitYieldExpression(node) {
|
|
emitTokenWithComment(125 /* YieldKeyword */, node.pos, writeKeyword, node);
|
|
emit(node.asteriskToken);
|
|
emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsiAndDisallowedComma);
|
|
}
|
|
function emitSpreadElement(node) {
|
|
emitTokenWithComment(25 /* 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, void 0);
|
|
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, void 0);
|
|
if (node.type) {
|
|
writeSpace();
|
|
writeKeyword("satisfies");
|
|
writeSpace();
|
|
emit(node.type);
|
|
}
|
|
}
|
|
function emitMetaProperty(node) {
|
|
writeToken(node.keywordToken, node.pos, writePunctuation);
|
|
writePunctuation(".");
|
|
emit(node.name);
|
|
}
|
|
function emitTemplateSpan(node) {
|
|
emitExpression(node.expression);
|
|
emit(node.literal);
|
|
}
|
|
function emitBlock(node) {
|
|
emitBlockStatements(node, !node.multiLine && isEmptyBlock(node));
|
|
}
|
|
function emitBlockStatements(node, forceSingleLine) {
|
|
emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
const format = forceSingleLine || getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineBlockStatements */ : 129 /* MultiLineBlockStatements */;
|
|
emitList(node, node.statements, format);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, node.statements.end, writePunctuation, node, !!(format & 1 /* MultiLine */));
|
|
}
|
|
function emitVariableStatement(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emit(node.declarationList);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitEmptyStatement(isEmbeddedStatement) {
|
|
if (isEmbeddedStatement) {
|
|
writePunctuation(";");
|
|
} else {
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitExpressionStatement(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfExpressionStatement);
|
|
if (!currentSourceFile || !isJsonSourceFile(currentSourceFile) || nodeIsSynthesized(node.expression)) {
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitIfStatement(node) {
|
|
const openParenPos = emitTokenWithComment(99 /* IfKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.thenStatement);
|
|
if (node.elseStatement) {
|
|
writeLineOrSpace(node, node.thenStatement, node.elseStatement);
|
|
emitTokenWithComment(91 /* ElseKeyword */, node.thenStatement.end, writeKeyword, node);
|
|
if (node.elseStatement.kind === 242 /* IfStatement */) {
|
|
writeSpace();
|
|
emit(node.elseStatement);
|
|
} else {
|
|
emitEmbeddedStatement(node, node.elseStatement);
|
|
}
|
|
}
|
|
}
|
|
function emitWhileClause(node, startPos) {
|
|
const openParenPos = emitTokenWithComment(115 /* WhileKeyword */, startPos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
}
|
|
function emitDoStatement(node) {
|
|
emitTokenWithComment(90 /* DoKeyword */, node.pos, writeKeyword, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
if (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) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
let pos = emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
pos = emitTokenWithComment(26 /* SemicolonToken */, node.initializer ? node.initializer.end : pos, writePunctuation, node);
|
|
emitExpressionWithLeadingSpace(node.condition);
|
|
pos = emitTokenWithComment(26 /* SemicolonToken */, node.condition ? node.condition.end : pos, writePunctuation, node);
|
|
emitExpressionWithLeadingSpace(node.incrementor);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.incrementor ? node.incrementor.end : pos, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForInStatement(node) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
writeSpace();
|
|
emitTokenWithComment(101 /* InKeyword */, node.initializer.end, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForOfStatement(node) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitWithTrailingSpace(node.awaitModifier);
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
writeSpace();
|
|
emitTokenWithComment(162 /* OfKeyword */, node.initializer.end, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForBinding(node) {
|
|
if (node !== void 0) {
|
|
if (node.kind === 258 /* VariableDeclarationList */) {
|
|
emit(node);
|
|
} else {
|
|
emitExpression(node);
|
|
}
|
|
}
|
|
}
|
|
function emitContinueStatement(node) {
|
|
emitTokenWithComment(86 /* ContinueKeyword */, node.pos, writeKeyword, node);
|
|
emitWithLeadingSpace(node.label);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitBreakStatement(node) {
|
|
emitTokenWithComment(81 /* BreakKeyword */, node.pos, writeKeyword, node);
|
|
emitWithLeadingSpace(node.label);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTokenWithComment(token, pos, writer2, contextNode, indentLeading) {
|
|
const node = getParseTreeNode(contextNode);
|
|
const isSimilarNode = node && node.kind === contextNode.kind;
|
|
const startPos = pos;
|
|
if (isSimilarNode && currentSourceFile) {
|
|
pos = skipTrivia(currentSourceFile.text, pos);
|
|
}
|
|
if (isSimilarNode && contextNode.pos !== startPos) {
|
|
const needsIndent = indentLeading && currentSourceFile && !positionsAreOnSameLine(startPos, pos, currentSourceFile);
|
|
if (needsIndent) {
|
|
increaseIndent();
|
|
}
|
|
emitLeadingCommentsOfPosition(startPos);
|
|
if (needsIndent) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
pos = writeTokenText(token, writer2, pos);
|
|
if (isSimilarNode && contextNode.end !== pos) {
|
|
const isJsxExprContext = contextNode.kind === 291 /* JsxExpression */;
|
|
emitTrailingCommentsOfPosition(pos, !isJsxExprContext, isJsxExprContext);
|
|
}
|
|
return pos;
|
|
}
|
|
function commentWillEmitNewLine(node) {
|
|
return node.kind === 2 /* SingleLineCommentTrivia */ || !!node.hasTrailingNewLine;
|
|
}
|
|
function willEmitLeadingNewLine(node) {
|
|
if (!currentSourceFile)
|
|
return false;
|
|
if (some(getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
|
|
return true;
|
|
if (some(getSyntheticLeadingComments(node), commentWillEmitNewLine))
|
|
return true;
|
|
if (isPartiallyEmittedExpression(node)) {
|
|
if (node.pos !== node.expression.pos) {
|
|
if (some(getTrailingCommentRanges(currentSourceFile.text, node.expression.pos), commentWillEmitNewLine))
|
|
return true;
|
|
}
|
|
return willEmitLeadingNewLine(node.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function parenthesizeExpressionForNoAsi(node) {
|
|
if (!commentsDisabled && isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) {
|
|
const parseNode = getParseTreeNode(node);
|
|
if (parseNode && isParenthesizedExpression(parseNode)) {
|
|
const parens = factory.createParenthesizedExpression(node.expression);
|
|
setOriginalNode(parens, node);
|
|
setTextRange(parens, parseNode);
|
|
return parens;
|
|
}
|
|
return factory.createParenthesizedExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function parenthesizeExpressionForNoAsiAndDisallowedComma(node) {
|
|
return parenthesizeExpressionForNoAsi(parenthesizer.parenthesizeExpressionForDisallowedComma(node));
|
|
}
|
|
function emitReturnStatement(node) {
|
|
emitTokenWithComment(105 /* ReturnKeyword */, node.pos, writeKeyword, node);
|
|
emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitWithStatement(node) {
|
|
const openParenPos = emitTokenWithComment(116 /* WithKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitSwitchStatement(node) {
|
|
const openParenPos = emitTokenWithComment(107 /* SwitchKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
writeSpace();
|
|
emit(node.caseBlock);
|
|
}
|
|
function emitLabeledStatement(node) {
|
|
emit(node.label);
|
|
emitTokenWithComment(58 /* ColonToken */, node.label.end, writePunctuation, node);
|
|
writeSpace();
|
|
emit(node.statement);
|
|
}
|
|
function emitThrowStatement(node) {
|
|
emitTokenWithComment(109 /* ThrowKeyword */, node.pos, writeKeyword, node);
|
|
emitExpressionWithLeadingSpace(parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTryStatement(node) {
|
|
emitTokenWithComment(111 /* 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 /* FinallyKeyword */, (node.catchClause || node.tryBlock).end, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.finallyBlock);
|
|
}
|
|
}
|
|
function emitDebuggerStatement(node) {
|
|
writeToken(87 /* DebuggerKeyword */, node.pos, writeKeyword);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitVariableDeclaration(node) {
|
|
var _a2, _b, _c, _d, _e;
|
|
emit(node.name);
|
|
emit(node.exclamationToken);
|
|
emitTypeAnnotation(node.type);
|
|
emitInitializer(node.initializer, (_e = (_d = (_a2 = node.type) == null ? void 0 : _a2.end) != null ? _d : (_c = (_b = node.name.emitNode) == null ? void 0 : _b.typeNode) == null ? void 0 : _c.end) != null ? _e : node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitVariableDeclarationList(node) {
|
|
writeKeyword(isLet(node) ? "let" : isVarConst(node) ? "const" : "var");
|
|
writeSpace();
|
|
emitList(node, node.declarations, 528 /* 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, emitSignatureHead2) {
|
|
const body = node.body;
|
|
if (body) {
|
|
if (isBlock(body)) {
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
pushNameGenerationScope(node);
|
|
forEach(node.parameters, generateNames);
|
|
generateNames(node.body);
|
|
emitSignatureHead2(node);
|
|
emitBlockFunctionBody(body);
|
|
popNameGenerationScope(node);
|
|
if (indentedFlag) {
|
|
decreaseIndent();
|
|
}
|
|
} else {
|
|
emitSignatureHead2(node);
|
|
writeSpace();
|
|
emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
|
|
}
|
|
} else {
|
|
emitSignatureHead2(node);
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitSignatureHead(node) {
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
}
|
|
function shouldEmitBlockFunctionBodyOnSingleLine(body) {
|
|
if (getEmitFlags(body) & 1 /* SingleLine */) {
|
|
return true;
|
|
}
|
|
if (body.multiLine) {
|
|
return false;
|
|
}
|
|
if (!nodeIsSynthesized(body) && currentSourceFile && !rangeIsOnSingleLine(body, currentSourceFile)) {
|
|
return false;
|
|
}
|
|
if (getLeadingLineTerminatorCount(body, firstOrUndefined(body.statements), 2 /* PreserveLines */) || getClosingLineTerminatorCount(body, lastOrUndefined(body.statements), 2 /* PreserveLines */, body.statements)) {
|
|
return false;
|
|
}
|
|
let previousStatement;
|
|
for (const statement of body.statements) {
|
|
if (getSeparatingLineTerminatorCount(previousStatement, statement, 2 /* PreserveLines */) > 0) {
|
|
return false;
|
|
}
|
|
previousStatement = statement;
|
|
}
|
|
return true;
|
|
}
|
|
function emitBlockFunctionBody(body) {
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(body);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
increaseIndent();
|
|
const emitBlockFunctionBody2 = shouldEmitBlockFunctionBodyOnSingleLine(body) ? emitBlockFunctionBodyOnSingleLine : emitBlockFunctionBodyWorker;
|
|
emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody2);
|
|
decreaseIndent();
|
|
writeToken(19 /* CloseBraceToken */, body.statements.end, writePunctuation, body);
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(body);
|
|
}
|
|
function emitBlockFunctionBodyOnSingleLine(body) {
|
|
emitBlockFunctionBodyWorker(body, true);
|
|
}
|
|
function emitBlockFunctionBodyWorker(body, emitBlockFunctionBodyOnSingleLine2) {
|
|
const statementOffset = emitPrologueDirectives(body.statements);
|
|
const pos = writer.getTextPos();
|
|
emitHelpers(body);
|
|
if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine2) {
|
|
decreaseIndent();
|
|
emitList(body, body.statements, 768 /* SingleLineFunctionBodyStatements */);
|
|
increaseIndent();
|
|
} else {
|
|
emitList(body, body.statements, 1 /* MultiLineFunctionBodyStatements */, void 0, statementOffset);
|
|
}
|
|
}
|
|
function emitClassDeclaration(node) {
|
|
emitClassDeclarationOrExpression(node);
|
|
}
|
|
function emitClassDeclarationOrExpression(node) {
|
|
forEach(node.members, generateMemberNames);
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
writeKeyword("class");
|
|
if (node.name) {
|
|
writeSpace();
|
|
emitIdentifierName(node.name);
|
|
}
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitList(node, node.heritageClauses, 0 /* ClassHeritageClauses */);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emitList(node, node.members, 129 /* 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 /* HeritageClauses */);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emitList(node, node.members, 129 /* 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 /* EnumMembers */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitModuleDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
if (~node.flags & 1024 /* GlobalAugmentation */) {
|
|
writeKeyword(node.flags & 16 /* Namespace */ ? "namespace" : "module");
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
let body = node.body;
|
|
if (!body)
|
|
return writeTrailingSemicolon();
|
|
while (body && isModuleDeclaration(body)) {
|
|
writePunctuation(".");
|
|
emit(body.name);
|
|
body = body.body;
|
|
}
|
|
writeSpace();
|
|
emit(body);
|
|
}
|
|
function emitModuleBlock(node) {
|
|
pushNameGenerationScope(node);
|
|
forEach(node.statements, generateNames);
|
|
emitBlockStatements(node, isEmptyBlock(node));
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitCaseBlock(node) {
|
|
emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
emitList(node, node.clauses, 129 /* CaseBlockClauses */);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, node.clauses.end, writePunctuation, node, true);
|
|
}
|
|
function emitImportEqualsDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitTokenWithComment(100 /* ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isTypeOnly) {
|
|
emitTokenWithComment(154 /* TypeKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
writeSpace();
|
|
emitTokenWithComment(63 /* EqualsToken */, node.name.end, writePunctuation, node);
|
|
writeSpace();
|
|
emitModuleReference(node.moduleReference);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitModuleReference(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitImportDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitTokenWithComment(100 /* ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.importClause) {
|
|
emit(node.importClause);
|
|
writeSpace();
|
|
emitTokenWithComment(158 /* 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 /* TypeKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
if (node.name && node.namedBindings) {
|
|
emitTokenWithComment(27 /* CommaToken */, node.name.end, writePunctuation, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.namedBindings);
|
|
}
|
|
function emitNamespaceImport(node) {
|
|
const asPos = emitTokenWithComment(41 /* AsteriskToken */, node.pos, writePunctuation, node);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* AsKeyword */, asPos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.name);
|
|
}
|
|
function emitNamedImports(node) {
|
|
emitNamedImportsOrExports(node);
|
|
}
|
|
function emitImportSpecifier(node) {
|
|
emitImportOrExportSpecifier(node);
|
|
}
|
|
function emitExportAssignment(node) {
|
|
const nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isExportEquals) {
|
|
emitTokenWithComment(63 /* EqualsToken */, nextPos, writeOperator, node);
|
|
} else {
|
|
emitTokenWithComment(88 /* DefaultKeyword */, nextPos, writeKeyword, node);
|
|
}
|
|
writeSpace();
|
|
emitExpression(node.expression, node.isExportEquals ? parenthesizer.getParenthesizeRightSideOfBinaryForOperator(63 /* EqualsToken */) : parenthesizer.parenthesizeExpressionOfExportDefault);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitExportDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
let nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isTypeOnly) {
|
|
nextPos = emitTokenWithComment(154 /* TypeKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
if (node.exportClause) {
|
|
emit(node.exportClause);
|
|
} else {
|
|
nextPos = emitTokenWithComment(41 /* AsteriskToken */, nextPos, writePunctuation, node);
|
|
}
|
|
if (node.moduleSpecifier) {
|
|
writeSpace();
|
|
const fromPos = node.exportClause ? node.exportClause.end : nextPos;
|
|
emitTokenWithComment(158 /* FromKeyword */, fromPos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.moduleSpecifier);
|
|
}
|
|
if (node.assertClause) {
|
|
emitWithLeadingSpace(node.assertClause);
|
|
}
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitAssertClause(node) {
|
|
emitTokenWithComment(130 /* AssertKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
const elements = node.elements;
|
|
emitList(node, elements, 526226 /* ImportClauseEntries */);
|
|
}
|
|
function emitAssertEntry(node) {
|
|
emit(node.name);
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
const value = node.value;
|
|
if ((getEmitFlags(value) & 1024 /* NoLeadingComments */) === 0) {
|
|
const commentRange = getCommentRange(value);
|
|
emitTrailingCommentsOfPosition(commentRange.pos);
|
|
}
|
|
emit(value);
|
|
}
|
|
function emitNamespaceExportDeclaration(node) {
|
|
let nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
nextPos = emitTokenWithComment(128 /* AsKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
nextPos = emitTokenWithComment(143 /* NamespaceKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.name);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitNamespaceExport(node) {
|
|
const asPos = emitTokenWithComment(41 /* AsteriskToken */, node.pos, writePunctuation, node);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* 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 /* NamedImportsOrExportsElements */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitImportOrExportSpecifier(node) {
|
|
if (node.isTypeOnly) {
|
|
writeKeyword("type");
|
|
writeSpace();
|
|
}
|
|
if (node.propertyName) {
|
|
emit(node.propertyName);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* AsKeyword */, node.propertyName.end, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
}
|
|
function emitExternalModuleReference(node) {
|
|
writeKeyword("require");
|
|
writePunctuation("(");
|
|
emitExpression(node.expression);
|
|
writePunctuation(")");
|
|
}
|
|
function emitJsxElement(node) {
|
|
emit(node.openingElement);
|
|
emitList(node, node.children, 262144 /* 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 /* JsxElementOrFragmentChildren */);
|
|
emit(node.closingFragment);
|
|
}
|
|
function emitJsxOpeningElementOrFragment(node) {
|
|
writePunctuation("<");
|
|
if (isJsxOpeningElement(node)) {
|
|
const 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("</");
|
|
if (isJsxClosingElement(node)) {
|
|
emitJsxTagName(node.tagName);
|
|
}
|
|
writePunctuation(">");
|
|
}
|
|
function emitJsxAttributes(node) {
|
|
emitList(node, node.properties, 262656 /* JsxElementAttributes */);
|
|
}
|
|
function emitJsxAttribute(node) {
|
|
emit(node.name);
|
|
emitNodeWithPrefix("=", writePunctuation, node.initializer, emitJsxAttributeValue);
|
|
}
|
|
function emitJsxSpreadAttribute(node) {
|
|
writePunctuation("{...");
|
|
emitExpression(node.expression);
|
|
writePunctuation("}");
|
|
}
|
|
function hasTrailingCommentsAtPosition(pos) {
|
|
let result = false;
|
|
forEachTrailingCommentRange((currentSourceFile == null ? void 0 : currentSourceFile.text) || "", pos + 1, () => result = true);
|
|
return result;
|
|
}
|
|
function hasLeadingCommentsAtPosition(pos) {
|
|
let result = false;
|
|
forEachLeadingCommentRange((currentSourceFile == null ? void 0 : currentSourceFile.text) || "", pos + 1, () => result = true);
|
|
return result;
|
|
}
|
|
function hasCommentsAtPosition(pos) {
|
|
return hasTrailingCommentsAtPosition(pos) || hasLeadingCommentsAtPosition(pos);
|
|
}
|
|
function emitJsxExpression(node) {
|
|
var _a2;
|
|
if (node.expression || !commentsDisabled && !nodeIsSynthesized(node) && hasCommentsAtPosition(node.pos)) {
|
|
const isMultiline = currentSourceFile && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(currentSourceFile, node.pos).line !== getLineAndCharacterOfPosition(currentSourceFile, node.end).line;
|
|
if (isMultiline) {
|
|
writer.increaseIndent();
|
|
}
|
|
const end = emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
emit(node.dotDotDotToken);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, ((_a2 = node.expression) == null ? void 0 : _a2.end) || end, writePunctuation, node);
|
|
if (isMultiline) {
|
|
writer.decreaseIndent();
|
|
}
|
|
}
|
|
}
|
|
function emitJsxTagName(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitCaseClause(node) {
|
|
emitTokenWithComment(82 /* CaseKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end);
|
|
}
|
|
function emitDefaultClause(node) {
|
|
const pos = emitTokenWithComment(88 /* DefaultKeyword */, node.pos, writeKeyword, node);
|
|
emitCaseOrDefaultClauseRest(node, node.statements, pos);
|
|
}
|
|
function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) {
|
|
const emitAsSingleStatement = statements.length === 1 && (!currentSourceFile || nodeIsSynthesized(parentNode) || nodeIsSynthesized(statements[0]) || rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile));
|
|
let format = 163969 /* CaseOrDefaultClauseStatements */;
|
|
if (emitAsSingleStatement) {
|
|
writeToken(58 /* ColonToken */, colonPos, writePunctuation, parentNode);
|
|
writeSpace();
|
|
format &= ~(1 /* MultiLine */ | 128 /* Indented */);
|
|
} else {
|
|
emitTokenWithComment(58 /* ColonToken */, colonPos, writePunctuation, parentNode);
|
|
}
|
|
emitList(parentNode, statements, format);
|
|
}
|
|
function emitHeritageClause(node) {
|
|
writeSpace();
|
|
writeTokenText(node.token, writeKeyword);
|
|
writeSpace();
|
|
emitList(node, node.types, 528 /* HeritageClauseTypes */);
|
|
}
|
|
function emitCatchClause(node) {
|
|
const openParenPos = emitTokenWithComment(83 /* CatchKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.variableDeclaration) {
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emit(node.variableDeclaration);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.variableDeclaration.end, writePunctuation, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.block);
|
|
}
|
|
function emitPropertyAssignment(node) {
|
|
emit(node.name);
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
const initializer = node.initializer;
|
|
if ((getEmitFlags(initializer) & 1024 /* NoLeadingComments */) === 0) {
|
|
const commentRange = 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 /* DotDotDotToken */, node.pos, writePunctuation, node);
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
}
|
|
function emitEnumMember(node) {
|
|
emit(node.name);
|
|
emitInitializer(node.initializer, node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitJSDoc(node) {
|
|
write("/**");
|
|
if (node.comment) {
|
|
const text = getTextOfJSDocComment(node.comment);
|
|
if (text) {
|
|
const lines = text.split(/\r\n?|\n/g);
|
|
for (const line of lines) {
|
|
writeLine();
|
|
writeSpace();
|
|
writePunctuation("*");
|
|
writeSpace();
|
|
write(line);
|
|
}
|
|
}
|
|
}
|
|
if (node.tags) {
|
|
if (node.tags.length === 1 && node.tags[0].kind === 346 /* JSDocTypeTag */ && !node.comment) {
|
|
writeSpace();
|
|
emit(node.tags[0]);
|
|
} else {
|
|
emitList(node, node.tags, 33 /* 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 /* CommaListElements */);
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocTypedefTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
if (tag.typeExpression) {
|
|
if (tag.typeExpression.kind === 312 /* 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 /* 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, factory.createNodeArray(lit.jsDocPropertyTags), 33 /* JSDocComment */);
|
|
}
|
|
function emitJSDocSignature(sig) {
|
|
if (sig.typeParameters) {
|
|
emitList(sig, factory.createNodeArray(sig.typeParameters), 33 /* JSDocComment */);
|
|
}
|
|
if (sig.parameters) {
|
|
emitList(sig, factory.createNodeArray(sig.parameters), 33 /* 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) {
|
|
const text = getTextOfJSDocComment(comment);
|
|
if (text) {
|
|
writeSpace();
|
|
write(text);
|
|
}
|
|
}
|
|
function emitJSDocTypeExpression(typeExpression) {
|
|
if (typeExpression) {
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emit(typeExpression.type);
|
|
writePunctuation("}");
|
|
}
|
|
}
|
|
function emitSourceFile(node) {
|
|
writeLine();
|
|
const statements = node.statements;
|
|
const shouldEmitDetachedComment = statements.length === 0 || !isPrologueDirective(statements[0]) || 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 (const prepend of node.prepends) {
|
|
if (isUnparsedSource(prepend) && prepend.syntheticReferences) {
|
|
for (const ref of prepend.syntheticReferences) {
|
|
emit(ref);
|
|
writeLine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitTripleSlashDirectivesIfNeeded(node) {
|
|
if (node.isDeclarationFile)
|
|
emitTripleSlashDirectives(node.hasNoDefaultLib, node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives);
|
|
}
|
|
function emitTripleSlashDirectives(hasNoDefaultLib, files, types, libs2) {
|
|
if (hasNoDefaultLib) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference no-default-lib="true"/>`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "no-default-lib" /* NoDefaultLib */ });
|
|
writeLine();
|
|
}
|
|
if (currentSourceFile && currentSourceFile.moduleName) {
|
|
writeComment(`/// <amd-module name="${currentSourceFile.moduleName}" />`);
|
|
writeLine();
|
|
}
|
|
if (currentSourceFile && currentSourceFile.amdDependencies) {
|
|
for (const dep of currentSourceFile.amdDependencies) {
|
|
if (dep.name) {
|
|
writeComment(`/// <amd-dependency name="${dep.name}" path="${dep.path}" />`);
|
|
} else {
|
|
writeComment(`/// <amd-dependency path="${dep.path}" />`);
|
|
}
|
|
writeLine();
|
|
}
|
|
}
|
|
for (const directive of files) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference path="${directive.fileName}" />`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
for (const directive of types) {
|
|
const pos = writer.getTextPos();
|
|
const resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile == null ? void 0 : currentSourceFile.impliedNodeFormat) ? `resolution-mode="${directive.resolutionMode === 99 /* ESNext */ ? "import" : "require"}"` : "";
|
|
writeComment(`/// <reference types="${directive.fileName}" ${resolutionMode}/>`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: !directive.resolutionMode ? "type" /* Type */ : directive.resolutionMode === 99 /* ESNext */ ? "type-import" /* TypeResolutionModeImport */ : "type-require" /* TypeResolutionModeRequire */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
for (const directive of libs2) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference lib="${directive.fileName}" />`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "lib" /* Lib */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
}
|
|
function emitSourceFileWorker(node) {
|
|
const statements = node.statements;
|
|
pushNameGenerationScope(node);
|
|
forEach(node.statements, generateNames);
|
|
emitHelpers(node);
|
|
const index = findIndex(statements, (statement) => !isPrologueDirective(statement));
|
|
emitTripleSlashDirectivesIfNeeded(node);
|
|
emitList(node, statements, 1 /* MultiLine */, void 0, index === -1 ? statements.length : index);
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitPartiallyEmittedExpression(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
if (!(emitFlags & 1024 /* NoLeadingComments */) && node.pos !== node.expression.pos) {
|
|
emitTrailingCommentsOfPosition(node.expression.pos);
|
|
}
|
|
emitExpression(node.expression);
|
|
if (!(emitFlags & 2048 /* NoTrailingComments */) && node.end !== node.expression.end) {
|
|
emitLeadingCommentsOfPosition(node.expression.end);
|
|
}
|
|
}
|
|
function emitCommaList(node) {
|
|
emitExpressionList(node, node.elements, 528 /* CommaListElements */, void 0);
|
|
}
|
|
function emitPrologueDirectives(statements, sourceFile, seenPrologueDirectives, recordBundleFileSection) {
|
|
let needsToSetSourceFile = !!sourceFile;
|
|
for (let i = 0; i < statements.length; i++) {
|
|
const statement = statements[i];
|
|
if (isPrologueDirective(statement)) {
|
|
const shouldEmitPrologueDirective = seenPrologueDirectives ? !seenPrologueDirectives.has(statement.expression.text) : true;
|
|
if (shouldEmitPrologueDirective) {
|
|
if (needsToSetSourceFile) {
|
|
needsToSetSourceFile = false;
|
|
setSourceFile(sourceFile);
|
|
}
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
emit(statement);
|
|
if (recordBundleFileSection && bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "prologue" /* Prologue */, data: statement.expression.text });
|
|
if (seenPrologueDirectives) {
|
|
seenPrologueDirectives.add(statement.expression.text);
|
|
}
|
|
}
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
return statements.length;
|
|
}
|
|
function emitUnparsedPrologues(prologues, seenPrologueDirectives) {
|
|
for (const prologue of prologues) {
|
|
if (!seenPrologueDirectives.has(prologue.data)) {
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
emit(prologue);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "prologue" /* Prologue */, data: prologue.data });
|
|
if (seenPrologueDirectives) {
|
|
seenPrologueDirectives.add(prologue.data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitPrologueDirectivesIfNeeded(sourceFileOrBundle) {
|
|
if (isSourceFile(sourceFileOrBundle)) {
|
|
emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle);
|
|
} else {
|
|
const seenPrologueDirectives = /* @__PURE__ */ new Set();
|
|
for (const prepend of sourceFileOrBundle.prepends) {
|
|
emitUnparsedPrologues(prepend.prologues, seenPrologueDirectives);
|
|
}
|
|
for (const sourceFile of sourceFileOrBundle.sourceFiles) {
|
|
emitPrologueDirectives(sourceFile.statements, sourceFile, seenPrologueDirectives, true);
|
|
}
|
|
setSourceFile(void 0);
|
|
}
|
|
}
|
|
function getPrologueDirectivesFromBundledSourceFiles(bundle) {
|
|
const seenPrologueDirectives = /* @__PURE__ */ new Set();
|
|
let prologues;
|
|
for (let index = 0; index < bundle.sourceFiles.length; index++) {
|
|
const sourceFile = bundle.sourceFiles[index];
|
|
let directives;
|
|
let end = 0;
|
|
for (const statement of sourceFile.statements) {
|
|
if (!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 });
|
|
}
|
|
return prologues;
|
|
}
|
|
function emitShebangIfNeeded(sourceFileOrBundle) {
|
|
if (isSourceFile(sourceFileOrBundle) || isUnparsedSource(sourceFileOrBundle)) {
|
|
const shebang = getShebang(sourceFileOrBundle.text);
|
|
if (shebang) {
|
|
writeComment(shebang);
|
|
writeLine();
|
|
return true;
|
|
}
|
|
} else {
|
|
for (const prepend of sourceFileOrBundle.prepends) {
|
|
Debug.assertNode(prepend, isUnparsedSource);
|
|
if (emitShebangIfNeeded(prepend)) {
|
|
return true;
|
|
}
|
|
}
|
|
for (const sourceFile of sourceFileOrBundle.sourceFiles) {
|
|
if (emitShebangIfNeeded(sourceFile)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitNodeWithWriter(node, writer2) {
|
|
if (!node)
|
|
return;
|
|
const savedWrite = write;
|
|
write = writer2;
|
|
emit(node);
|
|
write = savedWrite;
|
|
}
|
|
function emitDecoratorsAndModifiers(node, modifiers) {
|
|
if (modifiers == null ? void 0 : modifiers.length) {
|
|
if (every(modifiers, isModifier)) {
|
|
return emitModifiers(node, modifiers);
|
|
}
|
|
if (every(modifiers, isDecorator)) {
|
|
return emitDecorators(node, modifiers);
|
|
}
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(modifiers);
|
|
let lastMode;
|
|
let mode;
|
|
let start = 0;
|
|
let pos = 0;
|
|
while (start < modifiers.length) {
|
|
while (pos < modifiers.length) {
|
|
const modifier = modifiers[pos];
|
|
mode = isDecorator(modifier) ? "decorators" : "modifiers";
|
|
if (lastMode === void 0) {
|
|
lastMode = mode;
|
|
} else if (mode !== lastMode) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
const 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 /* Modifiers */ : 2146305 /* Decorators */,
|
|
void 0,
|
|
start,
|
|
pos - start,
|
|
false,
|
|
textRange
|
|
);
|
|
start = pos;
|
|
lastMode = mode;
|
|
pos++;
|
|
}
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(modifiers);
|
|
}
|
|
}
|
|
function emitModifiers(node, modifiers) {
|
|
emitList(node, modifiers, 2359808 /* Modifiers */);
|
|
}
|
|
function emitTypeAnnotation(node) {
|
|
if (node) {
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitInitializer(node, equalCommentStartPos, container, parenthesizerRule) {
|
|
if (node) {
|
|
writeSpace();
|
|
emitTokenWithComment(63 /* EqualsToken */, equalCommentStartPos, writeOperator, container);
|
|
writeSpace();
|
|
emitExpression(node, parenthesizerRule);
|
|
}
|
|
}
|
|
function emitNodeWithPrefix(prefix, prefixWriter, node, emit2) {
|
|
if (node) {
|
|
prefixWriter(prefix);
|
|
emit2(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 (isBlock(node) || getEmitFlags(parent) & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
emit(node);
|
|
} else {
|
|
writeLine();
|
|
increaseIndent();
|
|
if (isEmptyStatement(node)) {
|
|
pipelineEmit(5 /* EmbeddedStatement */, node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function emitDecorators(parentNode, decorators) {
|
|
emitList(parentNode, decorators, 2146305 /* Decorators */);
|
|
}
|
|
function emitTypeArguments(parentNode, typeArguments) {
|
|
emitList(parentNode, typeArguments, 53776 /* TypeArguments */, typeArgumentParenthesizerRuleSelector);
|
|
}
|
|
function emitTypeParameters(parentNode, typeParameters) {
|
|
if (isFunctionLike(parentNode) && parentNode.typeArguments) {
|
|
return emitTypeArguments(parentNode, parentNode.typeArguments);
|
|
}
|
|
emitList(parentNode, typeParameters, 53776 /* TypeParameters */);
|
|
}
|
|
function emitParameters(parentNode, parameters) {
|
|
emitList(parentNode, parameters, 2576 /* Parameters */);
|
|
}
|
|
function canEmitSimpleArrowHead(parentNode, parameters) {
|
|
const parameter = singleOrUndefined(parameters);
|
|
return parameter && parameter.pos === parentNode.pos && isArrowFunction(parentNode) && !parentNode.type && !some(parentNode.modifiers) && !some(parentNode.typeParameters) && !some(parameter.modifiers) && !parameter.dotDotDotToken && !parameter.questionToken && !parameter.type && !parameter.initializer && isIdentifier(parameter.name);
|
|
}
|
|
function emitParametersForArrow(parentNode, parameters) {
|
|
if (canEmitSimpleArrowHead(parentNode, parameters)) {
|
|
emitList(parentNode, parameters, 2576 /* Parameters */ & ~2048 /* Parenthesis */);
|
|
} else {
|
|
emitParameters(parentNode, parameters);
|
|
}
|
|
}
|
|
function emitParametersForIndexSignature(parentNode, parameters) {
|
|
emitList(parentNode, parameters, 8848 /* IndexSignatureParameters */);
|
|
}
|
|
function writeDelimiter(format) {
|
|
switch (format & 60 /* DelimitersMask */) {
|
|
case 0 /* None */:
|
|
break;
|
|
case 16 /* CommaDelimited */:
|
|
writePunctuation(",");
|
|
break;
|
|
case 4 /* BarDelimited */:
|
|
writeSpace();
|
|
writePunctuation("|");
|
|
break;
|
|
case 32 /* AsteriskDelimited */:
|
|
writeSpace();
|
|
writePunctuation("*");
|
|
writeSpace();
|
|
break;
|
|
case 8 /* AmpersandDelimited */:
|
|
writeSpace();
|
|
writePunctuation("&");
|
|
break;
|
|
}
|
|
}
|
|
function emitList(parentNode, children, format, parenthesizerRule, start, count) {
|
|
emitNodeList(
|
|
emit,
|
|
parentNode,
|
|
children,
|
|
format | (parentNode && getEmitFlags(parentNode) & 2 /* MultiLine */ ? 65536 /* PreferNewLine */ : 0),
|
|
parenthesizerRule,
|
|
start,
|
|
count
|
|
);
|
|
}
|
|
function emitExpressionList(parentNode, children, format, parenthesizerRule, start, count) {
|
|
emitNodeList(emitExpression, parentNode, children, format, parenthesizerRule, start, count);
|
|
}
|
|
function emitNodeList(emit2, parentNode, children, format, parenthesizerRule, start = 0, count = children ? children.length - start : 0) {
|
|
const isUndefined = children === void 0;
|
|
if (isUndefined && format & 16384 /* OptionalIfUndefined */) {
|
|
return;
|
|
}
|
|
const isEmpty = children === void 0 || start >= children.length || count === 0;
|
|
if (isEmpty && format & 32768 /* OptionalIfEmpty */) {
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(children);
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(children);
|
|
return;
|
|
}
|
|
if (format & 15360 /* BracketsMask */) {
|
|
writePunctuation(getOpeningBracket(format));
|
|
if (isEmpty && children) {
|
|
emitTrailingCommentsOfPosition(children.pos, true);
|
|
}
|
|
}
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(children);
|
|
if (isEmpty) {
|
|
if (format & 1 /* MultiLine */ && !(preserveSourceNewlines && (!parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile)))) {
|
|
writeLine();
|
|
} else if (format & 256 /* SpaceBetweenBraces */ && !(format & 524288 /* NoSpaceIfEmpty */)) {
|
|
writeSpace();
|
|
}
|
|
} else {
|
|
emitNodeListItems(emit2, parentNode, children, format, parenthesizerRule, start, count, children.hasTrailingComma, children);
|
|
}
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(children);
|
|
if (format & 15360 /* BracketsMask */) {
|
|
if (isEmpty && children) {
|
|
emitLeadingCommentsOfPosition(children.end);
|
|
}
|
|
writePunctuation(getClosingBracket(format));
|
|
}
|
|
}
|
|
function emitNodeListItems(emit2, parentNode, children, format, parenthesizerRule, start, count, hasTrailingComma, childrenTextRange) {
|
|
const mayEmitInterveningComments = (format & 262144 /* NoInterveningComments */) === 0;
|
|
let shouldEmitInterveningComments = mayEmitInterveningComments;
|
|
const leadingLineTerminatorCount = getLeadingLineTerminatorCount(parentNode, children[start], format);
|
|
if (leadingLineTerminatorCount) {
|
|
writeLine(leadingLineTerminatorCount);
|
|
shouldEmitInterveningComments = false;
|
|
} else if (format & 256 /* SpaceBetweenBraces */) {
|
|
writeSpace();
|
|
}
|
|
if (format & 128 /* Indented */) {
|
|
increaseIndent();
|
|
}
|
|
const emitListItem = getEmitListItem(emit2, parenthesizerRule);
|
|
let previousSibling;
|
|
let previousSourceFileTextKind;
|
|
let shouldDecreaseIndentAfterEmit = false;
|
|
for (let i = 0; i < count; i++) {
|
|
const child = children[start + i];
|
|
if (format & 32 /* AsteriskDelimited */) {
|
|
writeLine();
|
|
writeDelimiter(format);
|
|
} else if (previousSibling) {
|
|
if (format & 60 /* DelimitersMask */ && previousSibling.end !== (parentNode ? parentNode.end : -1)) {
|
|
emitLeadingCommentsOfPosition(previousSibling.end);
|
|
}
|
|
writeDelimiter(format);
|
|
recordBundleFileInternalSectionEnd(previousSourceFileTextKind);
|
|
const separatingLineTerminatorCount = getSeparatingLineTerminatorCount(previousSibling, child, format);
|
|
if (separatingLineTerminatorCount > 0) {
|
|
if ((format & (3 /* LinesMask */ | 128 /* Indented */)) === 0 /* SingleLine */) {
|
|
increaseIndent();
|
|
shouldDecreaseIndentAfterEmit = true;
|
|
}
|
|
writeLine(separatingLineTerminatorCount);
|
|
shouldEmitInterveningComments = false;
|
|
} else if (previousSibling && format & 512 /* SpaceBetweenSiblings */) {
|
|
writeSpace();
|
|
}
|
|
}
|
|
previousSourceFileTextKind = recordBundleFileInternalSectionStart(child);
|
|
if (shouldEmitInterveningComments) {
|
|
const commentRange = getCommentRange(child);
|
|
emitTrailingCommentsOfPosition(commentRange.pos);
|
|
} else {
|
|
shouldEmitInterveningComments = mayEmitInterveningComments;
|
|
}
|
|
nextListElementPos = child.pos;
|
|
emitListItem(child, emit2, parenthesizerRule, i);
|
|
if (shouldDecreaseIndentAfterEmit) {
|
|
decreaseIndent();
|
|
shouldDecreaseIndentAfterEmit = false;
|
|
}
|
|
previousSibling = child;
|
|
}
|
|
const emitFlags = previousSibling ? getEmitFlags(previousSibling) : 0;
|
|
const skipTrailingComments = commentsDisabled || !!(emitFlags & 2048 /* NoTrailingComments */);
|
|
const emitTrailingComma = hasTrailingComma && format & 64 /* AllowTrailingComma */ && format & 16 /* CommaDelimited */;
|
|
if (emitTrailingComma) {
|
|
if (previousSibling && !skipTrailingComments) {
|
|
emitTokenWithComment(27 /* CommaToken */, previousSibling.end, writePunctuation, previousSibling);
|
|
} else {
|
|
writePunctuation(",");
|
|
}
|
|
}
|
|
if (previousSibling && (parentNode ? parentNode.end : -1) !== previousSibling.end && format & 60 /* DelimitersMask */ && !skipTrailingComments) {
|
|
emitLeadingCommentsOfPosition(emitTrailingComma && (childrenTextRange == null ? void 0 : childrenTextRange.end) ? childrenTextRange.end : previousSibling.end);
|
|
}
|
|
if (format & 128 /* Indented */) {
|
|
decreaseIndent();
|
|
}
|
|
recordBundleFileInternalSectionEnd(previousSourceFileTextKind);
|
|
const closingLineTerminatorCount = getClosingLineTerminatorCount(parentNode, children[start + count - 1], format, childrenTextRange);
|
|
if (closingLineTerminatorCount) {
|
|
writeLine(closingLineTerminatorCount);
|
|
} else if (format & (2097152 /* SpaceAfterList */ | 256 /* SpaceBetweenBraces */)) {
|
|
writeSpace();
|
|
}
|
|
}
|
|
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) {
|
|
if (writer.nonEscapingWrite) {
|
|
writer.nonEscapingWrite(s);
|
|
} else {
|
|
writer.write(s);
|
|
}
|
|
}
|
|
function writeLine(count = 1) {
|
|
for (let i = 0; i < count; i++) {
|
|
writer.writeLine(i > 0);
|
|
}
|
|
}
|
|
function increaseIndent() {
|
|
writer.increaseIndent();
|
|
}
|
|
function decreaseIndent() {
|
|
writer.decreaseIndent();
|
|
}
|
|
function writeToken(token, pos, writer2, contextNode) {
|
|
return !sourceMapsDisabled ? emitTokenWithSourceMap(contextNode, token, writer2, pos, writeTokenText) : writeTokenText(token, writer2, pos);
|
|
}
|
|
function writeTokenNode(node, writer2) {
|
|
if (onBeforeEmitToken) {
|
|
onBeforeEmitToken(node);
|
|
}
|
|
writer2(tokenToString(node.kind));
|
|
if (onAfterEmitToken) {
|
|
onAfterEmitToken(node);
|
|
}
|
|
}
|
|
function writeTokenText(token, writer2, pos) {
|
|
const tokenString = tokenToString(token);
|
|
writer2(tokenString);
|
|
return pos < 0 ? pos : pos + tokenString.length;
|
|
}
|
|
function writeLineOrSpace(parentNode, prevChildNode, nextChildNode) {
|
|
if (getEmitFlags(parentNode) & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else if (preserveSourceNewlines) {
|
|
const lines = getLinesBetweenNodes(parentNode, prevChildNode, nextChildNode);
|
|
if (lines) {
|
|
writeLine(lines);
|
|
} else {
|
|
writeSpace();
|
|
}
|
|
} else {
|
|
writeLine();
|
|
}
|
|
}
|
|
function writeLines(text) {
|
|
const lines = text.split(/\r\n?|\n/g);
|
|
const indentation = guessIndentation(lines);
|
|
for (const lineText of lines) {
|
|
const 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();
|
|
}
|
|
}
|
|
function decreaseIndentIf(value1, value2) {
|
|
if (value1) {
|
|
decreaseIndent();
|
|
}
|
|
if (value2) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function getLeadingLineTerminatorCount(parentNode, firstChild, format) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (format & 65536 /* PreferNewLine */) {
|
|
return 1;
|
|
}
|
|
if (firstChild === void 0) {
|
|
return !parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (firstChild.pos === nextListElementPos) {
|
|
return 0;
|
|
}
|
|
if (firstChild.kind === 11 /* JsxText */) {
|
|
return 0;
|
|
}
|
|
if (currentSourceFile && parentNode && !positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(firstChild) && (!firstChild.parent || getOriginalNode(firstChild.parent) === getOriginalNode(parentNode))) {
|
|
if (preserveSourceNewlines) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(
|
|
firstChild.pos,
|
|
parentNode.pos,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (synthesizedNodeStartsOnNewLine(firstChild, format)) {
|
|
return 1;
|
|
}
|
|
}
|
|
return format & 1 /* MultiLine */ ? 1 : 0;
|
|
}
|
|
function getSeparatingLineTerminatorCount(previousNode, nextNode, format) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (previousNode === void 0 || nextNode === void 0) {
|
|
return 0;
|
|
}
|
|
if (nextNode.kind === 11 /* JsxText */) {
|
|
return 0;
|
|
} else if (currentSourceFile && !nodeIsSynthesized(previousNode) && !nodeIsSynthesized(nextNode)) {
|
|
if (preserveSourceNewlines && siblingNodePositionsAreComparable(previousNode, nextNode)) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenRangeEndAndRangeStart(
|
|
previousNode,
|
|
nextNode,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
} else if (!preserveSourceNewlines && originalNodesHaveSameParent(previousNode, nextNode)) {
|
|
return rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
return format & 65536 /* PreferNewLine */ ? 1 : 0;
|
|
} else if (synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format)) {
|
|
return 1;
|
|
}
|
|
} else if (getStartsOnNewLine(nextNode)) {
|
|
return 1;
|
|
}
|
|
return format & 1 /* MultiLine */ ? 1 : 0;
|
|
}
|
|
function getClosingLineTerminatorCount(parentNode, lastChild, format, childrenTextRange) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (format & 65536 /* PreferNewLine */) {
|
|
return 1;
|
|
}
|
|
if (lastChild === void 0) {
|
|
return !parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (currentSourceFile && parentNode && !positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) {
|
|
if (preserveSourceNewlines) {
|
|
const end = childrenTextRange && !positionIsSynthesized(childrenTextRange.end) ? childrenTextRange.end : lastChild.end;
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenPositionAndNextNonWhitespaceCharacter(
|
|
end,
|
|
parentNode.end,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (synthesizedNodeStartsOnNewLine(lastChild, format)) {
|
|
return 1;
|
|
}
|
|
}
|
|
if (format & 1 /* MultiLine */ && !(format & 131072 /* NoTrailingNewLine */)) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function getEffectiveLines(getLineDifference) {
|
|
Debug.assert(!!preserveSourceNewlines);
|
|
const lines = getLineDifference(true);
|
|
if (lines === 0) {
|
|
return getLineDifference(false);
|
|
}
|
|
return lines;
|
|
}
|
|
function writeLineSeparatorsAndIndentBefore(node, parent) {
|
|
const leadingNewlines = preserveSourceNewlines && getLeadingLineTerminatorCount(parent, node, 0 /* None */);
|
|
if (leadingNewlines) {
|
|
writeLinesAndIndent(leadingNewlines, false);
|
|
}
|
|
return !!leadingNewlines;
|
|
}
|
|
function writeLineSeparatorsAfter(node, parent) {
|
|
const trailingNewlines = preserveSourceNewlines && getClosingLineTerminatorCount(parent, node, 0 /* None */, void 0);
|
|
if (trailingNewlines) {
|
|
writeLine(trailingNewlines);
|
|
}
|
|
}
|
|
function synthesizedNodeStartsOnNewLine(node, format) {
|
|
if (nodeIsSynthesized(node)) {
|
|
const startsOnNewLine = getStartsOnNewLine(node);
|
|
if (startsOnNewLine === void 0) {
|
|
return (format & 65536 /* PreferNewLine */) !== 0;
|
|
}
|
|
return startsOnNewLine;
|
|
}
|
|
return (format & 65536 /* PreferNewLine */) !== 0;
|
|
}
|
|
function getLinesBetweenNodes(parent, node1, node2) {
|
|
if (getEmitFlags(parent) & 262144 /* NoIndentation */) {
|
|
return 0;
|
|
}
|
|
parent = skipSynthesizedParentheses(parent);
|
|
node1 = skipSynthesizedParentheses(node1);
|
|
node2 = skipSynthesizedParentheses(node2);
|
|
if (getStartsOnNewLine(node2)) {
|
|
return 1;
|
|
}
|
|
if (currentSourceFile && !nodeIsSynthesized(parent) && !nodeIsSynthesized(node1) && !nodeIsSynthesized(node2)) {
|
|
if (preserveSourceNewlines) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenRangeEndAndRangeStart(
|
|
node1,
|
|
node2,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile) ? 0 : 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function isEmptyBlock(block) {
|
|
return block.statements.length === 0 && (!currentSourceFile || rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile));
|
|
}
|
|
function skipSynthesizedParentheses(node) {
|
|
while (node.kind === 214 /* ParenthesizedExpression */ && nodeIsSynthesized(node)) {
|
|
node = node.expression;
|
|
}
|
|
return node;
|
|
}
|
|
function getTextOfNode2(node, includeTrivia) {
|
|
if (isGeneratedIdentifier(node) || isGeneratedPrivateIdentifier(node)) {
|
|
return generateName(node);
|
|
}
|
|
if (isStringLiteral(node) && node.textSourceNode) {
|
|
return getTextOfNode2(node.textSourceNode, includeTrivia);
|
|
}
|
|
const sourceFile = currentSourceFile;
|
|
const canUseSourceFile = !!sourceFile && !!node.parent && !nodeIsSynthesized(node);
|
|
if (isMemberName(node)) {
|
|
if (!canUseSourceFile || getSourceFileOfNode(node) !== getOriginalNode(sourceFile)) {
|
|
return idText(node);
|
|
}
|
|
} else {
|
|
Debug.assertNode(node, isLiteralExpression);
|
|
if (!canUseSourceFile) {
|
|
return node.text;
|
|
}
|
|
}
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia);
|
|
}
|
|
function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) {
|
|
if (node.kind === 10 /* StringLiteral */ && node.textSourceNode) {
|
|
const textSourceNode = node.textSourceNode;
|
|
if (isIdentifier(textSourceNode) || isPrivateIdentifier(textSourceNode) || isNumericLiteral(textSourceNode)) {
|
|
const text = isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode2(textSourceNode);
|
|
return jsxAttributeEscape ? `"${escapeJsxAttributeString(text)}"` : neverAsciiEscape || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? `"${escapeString(text)}"` : `"${escapeNonAsciiString(text)}"`;
|
|
} else {
|
|
return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);
|
|
}
|
|
}
|
|
const flags = (neverAsciiEscape ? 1 /* NeverAsciiEscape */ : 0) | (jsxAttributeEscape ? 2 /* JsxAttributeEscape */ : 0) | (printerOptions.terminateUnterminatedLiterals ? 4 /* TerminateUnterminatedLiterals */ : 0) | (printerOptions.target && printerOptions.target === 99 /* ESNext */ ? 8 /* AllowNumericSeparator */ : 0);
|
|
return getLiteralText(node, currentSourceFile, flags);
|
|
}
|
|
function pushNameGenerationScope(node) {
|
|
if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
return;
|
|
}
|
|
tempFlagsStack.push(tempFlags);
|
|
tempFlags = TempFlags.Auto;
|
|
privateNameTempFlagsStack.push(privateNameTempFlags);
|
|
privateNameTempFlags = TempFlags.Auto;
|
|
formattedNameTempFlagsStack.push(formattedNameTempFlags);
|
|
formattedNameTempFlags = void 0;
|
|
reservedNamesStack.push(reservedNames);
|
|
}
|
|
function popNameGenerationScope(node) {
|
|
if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
return;
|
|
}
|
|
tempFlags = tempFlagsStack.pop();
|
|
privateNameTempFlags = privateNameTempFlagsStack.pop();
|
|
formattedNameTempFlags = formattedNameTempFlagsStack.pop();
|
|
reservedNames = reservedNamesStack.pop();
|
|
}
|
|
function reserveNameInNestedScopes(name) {
|
|
if (!reservedNames || reservedNames === lastOrUndefined(reservedNamesStack)) {
|
|
reservedNames = /* @__PURE__ */ new Set();
|
|
}
|
|
reservedNames.add(name);
|
|
}
|
|
function generateNames(node) {
|
|
if (!node)
|
|
return;
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
forEach(node.statements, generateNames);
|
|
break;
|
|
case 253 /* LabeledStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
generateNames(node.statement);
|
|
break;
|
|
case 242 /* IfStatement */:
|
|
generateNames(node.thenStatement);
|
|
generateNames(node.elseStatement);
|
|
break;
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
generateNames(node.initializer);
|
|
generateNames(node.statement);
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
generateNames(node.caseBlock);
|
|
break;
|
|
case 266 /* CaseBlock */:
|
|
forEach(node.clauses, generateNames);
|
|
break;
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
forEach(node.statements, generateNames);
|
|
break;
|
|
case 255 /* TryStatement */:
|
|
generateNames(node.tryBlock);
|
|
generateNames(node.catchClause);
|
|
generateNames(node.finallyBlock);
|
|
break;
|
|
case 295 /* CatchClause */:
|
|
generateNames(node.variableDeclaration);
|
|
generateNames(node.block);
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
generateNames(node.declarationList);
|
|
break;
|
|
case 258 /* VariableDeclarationList */:
|
|
forEach(node.declarations, generateNames);
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
generateNameIfNeeded(node.name);
|
|
if (getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
forEach(node.parameters, generateNames);
|
|
generateNames(node.body);
|
|
}
|
|
break;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
forEach(node.elements, generateNames);
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
generateNames(node.importClause);
|
|
break;
|
|
case 270 /* ImportClause */:
|
|
generateNameIfNeeded(node.name);
|
|
generateNames(node.namedBindings);
|
|
break;
|
|
case 271 /* NamespaceImport */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 277 /* NamespaceExport */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
forEach(node.elements, generateNames);
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
generateNameIfNeeded(node.propertyName || node.name);
|
|
break;
|
|
}
|
|
}
|
|
function generateMemberNames(node) {
|
|
if (!node)
|
|
return;
|
|
switch (node.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
}
|
|
}
|
|
function generateNameIfNeeded(name) {
|
|
if (name) {
|
|
if (isGeneratedIdentifier(name) || isGeneratedPrivateIdentifier(name)) {
|
|
generateName(name);
|
|
} else if (isBindingPattern(name)) {
|
|
generateNames(name);
|
|
}
|
|
}
|
|
}
|
|
function generateName(name) {
|
|
if ((name.autoGenerateFlags & 7 /* KindMask */) === 4 /* Node */) {
|
|
return generateNameCached(getNodeForGeneratedName(name), isPrivateIdentifier(name), name.autoGenerateFlags, name.autoGeneratePrefix, name.autoGenerateSuffix);
|
|
} else {
|
|
const autoGenerateId = name.autoGenerateId;
|
|
return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = makeName(name));
|
|
}
|
|
}
|
|
function generateNameCached(node, privateName, flags, prefix, suffix) {
|
|
const nodeId = getNodeId(node);
|
|
return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, privateName, flags != null ? flags : 0 /* None */, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
|
|
}
|
|
function isUniqueName(name) {
|
|
return isFileLevelUniqueName2(name) && !generatedNames.has(name) && !(reservedNames && reservedNames.has(name));
|
|
}
|
|
function isFileLevelUniqueName2(name) {
|
|
return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
|
|
}
|
|
function isUniqueLocalName(name, container) {
|
|
for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
|
|
if (node.locals) {
|
|
const local = node.locals.get(escapeLeadingUnderscores(name));
|
|
if (local && local.flags & (111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getTempFlags(formattedNameKey) {
|
|
var _a2;
|
|
switch (formattedNameKey) {
|
|
case "":
|
|
return tempFlags;
|
|
case "#":
|
|
return privateNameTempFlags;
|
|
default:
|
|
return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : TempFlags.Auto;
|
|
}
|
|
}
|
|
function setTempFlags(formattedNameKey, flags) {
|
|
switch (formattedNameKey) {
|
|
case "":
|
|
tempFlags = flags;
|
|
break;
|
|
case "#":
|
|
privateNameTempFlags = flags;
|
|
break;
|
|
default:
|
|
formattedNameTempFlags != null ? formattedNameTempFlags : formattedNameTempFlags = /* @__PURE__ */ new Map();
|
|
formattedNameTempFlags.set(formattedNameKey, flags);
|
|
break;
|
|
}
|
|
}
|
|
function makeTempVariableName(flags, reservedInNestedScopes, privateName, prefix, suffix) {
|
|
if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* hash */) {
|
|
prefix = prefix.slice(1);
|
|
}
|
|
const key = formatGeneratedName(privateName, prefix, "", suffix);
|
|
let tempFlags2 = getTempFlags(key);
|
|
if (flags && !(tempFlags2 & flags)) {
|
|
const name = flags === TempFlags._i ? "_i" : "_n";
|
|
const fullName = formatGeneratedName(privateName, prefix, name, suffix);
|
|
if (isUniqueName(fullName)) {
|
|
tempFlags2 |= flags;
|
|
if (reservedInNestedScopes) {
|
|
reserveNameInNestedScopes(fullName);
|
|
}
|
|
setTempFlags(key, tempFlags2);
|
|
return fullName;
|
|
}
|
|
}
|
|
while (true) {
|
|
const count = tempFlags2 & TempFlags.CountMask;
|
|
tempFlags2++;
|
|
if (count !== 8 && count !== 13) {
|
|
const name = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);
|
|
const fullName = formatGeneratedName(privateName, prefix, name, suffix);
|
|
if (isUniqueName(fullName)) {
|
|
if (reservedInNestedScopes) {
|
|
reserveNameInNestedScopes(fullName);
|
|
}
|
|
setTempFlags(key, tempFlags2);
|
|
return fullName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function makeUniqueName(baseName, checkFn = isUniqueName, optimistic, scoped, privateName, prefix, suffix) {
|
|
if (baseName.length > 0 && baseName.charCodeAt(0) === 35 /* hash */) {
|
|
baseName = baseName.slice(1);
|
|
}
|
|
if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* hash */) {
|
|
prefix = prefix.slice(1);
|
|
}
|
|
if (optimistic) {
|
|
const fullName = formatGeneratedName(privateName, prefix, baseName, suffix);
|
|
if (checkFn(fullName)) {
|
|
if (scoped) {
|
|
reserveNameInNestedScopes(fullName);
|
|
} else {
|
|
generatedNames.add(fullName);
|
|
}
|
|
return fullName;
|
|
}
|
|
}
|
|
if (baseName.charCodeAt(baseName.length - 1) !== 95 /* _ */) {
|
|
baseName += "_";
|
|
}
|
|
let i = 1;
|
|
while (true) {
|
|
const fullName = 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, isFileLevelUniqueName2, true, false, false, "", "");
|
|
}
|
|
function generateNameForModuleOrEnum(node) {
|
|
const name = getTextOfNode2(node.name);
|
|
return isUniqueLocalName(name, node) ? name : makeUniqueName(name, isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForImportOrExportDeclaration(node) {
|
|
const expr = getExternalModuleName(node);
|
|
const baseName = isStringLiteral(expr) ? makeIdentifierFromModuleName(expr.text) : "module";
|
|
return makeUniqueName(baseName, isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForExportDefault() {
|
|
return makeUniqueName("default", isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForClassExpression() {
|
|
return makeUniqueName("class", isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForMethodOrAccessor(node, privateName, prefix, suffix) {
|
|
if (isIdentifier(node.name)) {
|
|
return generateNameCached(node.name, privateName);
|
|
}
|
|
return makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
|
|
}
|
|
function generateNameForNode(node, privateName, flags, prefix, suffix) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return makeUniqueName(
|
|
getTextOfNode2(node),
|
|
isUniqueName,
|
|
!!(flags & 16 /* Optimistic */),
|
|
!!(flags & 8 /* ReservedInNestedScopes */),
|
|
privateName,
|
|
prefix,
|
|
suffix
|
|
);
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForModuleOrEnum(node);
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForImportOrExportDeclaration(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForExportDefault();
|
|
case 228 /* ClassExpression */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForClassExpression();
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
|
|
case 164 /* ComputedPropertyName */:
|
|
return makeTempVariableName(TempFlags.Auto, true, privateName, prefix, suffix);
|
|
default:
|
|
return makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
|
|
}
|
|
}
|
|
function makeName(name) {
|
|
const prefix = formatGeneratedNamePart(name.autoGeneratePrefix, generateName);
|
|
const suffix = formatGeneratedNamePart(name.autoGenerateSuffix);
|
|
switch (name.autoGenerateFlags & 7 /* KindMask */) {
|
|
case 1 /* Auto */:
|
|
return makeTempVariableName(TempFlags.Auto, !!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
|
|
case 2 /* Loop */:
|
|
Debug.assertNode(name, isIdentifier);
|
|
return makeTempVariableName(TempFlags._i, !!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */), false, prefix, suffix);
|
|
case 3 /* Unique */:
|
|
return makeUniqueName(
|
|
idText(name),
|
|
name.autoGenerateFlags & 32 /* FileLevel */ ? isFileLevelUniqueName2 : isUniqueName,
|
|
!!(name.autoGenerateFlags & 16 /* Optimistic */),
|
|
!!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */),
|
|
isPrivateIdentifier(name),
|
|
prefix,
|
|
suffix
|
|
);
|
|
}
|
|
return Debug.fail(`Unsupported GeneratedIdentifierKind: ${Debug.formatEnum(name.autoGenerateFlags & 7 /* KindMask */, GeneratedIdentifierFlags, true)}.`);
|
|
}
|
|
function pipelineEmitWithComments(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(2 /* Comments */, hint, node);
|
|
const savedContainerPos = containerPos;
|
|
const savedContainerEnd = containerEnd;
|
|
const savedDeclarationListContainerEnd = declarationListContainerEnd;
|
|
emitCommentsBeforeNode(node);
|
|
pipelinePhase(hint, node);
|
|
emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
}
|
|
function emitCommentsBeforeNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const commentRange = getCommentRange(node);
|
|
emitLeadingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end);
|
|
if (emitFlags & 4096 /* NoNestedComments */) {
|
|
commentsDisabled = true;
|
|
}
|
|
}
|
|
function emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const commentRange = getCommentRange(node);
|
|
if (emitFlags & 4096 /* NoNestedComments */) {
|
|
commentsDisabled = false;
|
|
}
|
|
emitTrailingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
const typeNode = getTypeNode(node);
|
|
if (typeNode) {
|
|
emitTrailingCommentsOfNode(node, emitFlags, typeNode.pos, typeNode.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
}
|
|
}
|
|
function emitLeadingCommentsOfNode(node, emitFlags, pos, end) {
|
|
enterComment();
|
|
hasWrittenComment = false;
|
|
const skipLeadingComments = pos < 0 || (emitFlags & 1024 /* NoLeadingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
const skipTrailingComments = end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
if ((pos > 0 || end > 0) && pos !== end) {
|
|
if (!skipLeadingComments) {
|
|
emitLeadingComments(pos, node.kind !== 352 /* NotEmittedStatement */);
|
|
}
|
|
if (!skipLeadingComments || pos >= 0 && (emitFlags & 1024 /* NoLeadingComments */) !== 0) {
|
|
containerPos = pos;
|
|
}
|
|
if (!skipTrailingComments || end >= 0 && (emitFlags & 2048 /* NoTrailingComments */) !== 0) {
|
|
containerEnd = end;
|
|
if (node.kind === 258 /* VariableDeclarationList */) {
|
|
declarationListContainerEnd = end;
|
|
}
|
|
}
|
|
}
|
|
forEach(getSyntheticLeadingComments(node), emitLeadingSynthesizedComment);
|
|
exitComment();
|
|
}
|
|
function emitTrailingCommentsOfNode(node, emitFlags, pos, end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) {
|
|
enterComment();
|
|
const skipTrailingComments = end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
forEach(getSyntheticTrailingComments(node), emitTrailingSynthesizedComment);
|
|
if ((pos > 0 || end > 0) && pos !== end) {
|
|
containerPos = savedContainerPos;
|
|
containerEnd = savedContainerEnd;
|
|
declarationListContainerEnd = savedDeclarationListContainerEnd;
|
|
if (!skipTrailingComments && node.kind !== 352 /* NotEmittedStatement */) {
|
|
emitTrailingComments(end);
|
|
}
|
|
}
|
|
exitComment();
|
|
}
|
|
function emitLeadingSynthesizedComment(comment) {
|
|
if (comment.hasLeadingNewline || comment.kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
}
|
|
writeSynthesizedComment(comment);
|
|
if (comment.hasTrailingNewLine || comment.kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
} else {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function emitTrailingSynthesizedComment(comment) {
|
|
if (!writer.isAtStartOfLine()) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
writeSynthesizedComment(comment);
|
|
if (comment.hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function writeSynthesizedComment(comment) {
|
|
const text = formatSynthesizedComment(comment);
|
|
const lineMap = comment.kind === 3 /* MultiLineCommentTrivia */ ? computeLineStarts(text) : void 0;
|
|
writeCommentRange(text, lineMap, writer, 0, text.length, newLine);
|
|
}
|
|
function formatSynthesizedComment(comment) {
|
|
return comment.kind === 3 /* MultiLineCommentTrivia */ ? `/*${comment.text}*/` : `//${comment.text}`;
|
|
}
|
|
function emitBodyWithDetachedComments(node, detachedRange, emitCallback) {
|
|
enterComment();
|
|
const { pos, end } = detachedRange;
|
|
const emitFlags = getEmitFlags(node);
|
|
const skipLeadingComments = pos < 0 || (emitFlags & 1024 /* NoLeadingComments */) !== 0;
|
|
const skipTrailingComments = commentsDisabled || end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0;
|
|
if (!skipLeadingComments) {
|
|
emitDetachedCommentsAndUpdateCommentsInfo(detachedRange);
|
|
}
|
|
exitComment();
|
|
if (emitFlags & 4096 /* NoNestedComments */ && !commentsDisabled) {
|
|
commentsDisabled = true;
|
|
emitCallback(node);
|
|
commentsDisabled = false;
|
|
} else {
|
|
emitCallback(node);
|
|
}
|
|
enterComment();
|
|
if (!skipTrailingComments) {
|
|
emitLeadingComments(detachedRange.end, true);
|
|
if (hasWrittenComment && !writer.isAtStartOfLine()) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
exitComment();
|
|
}
|
|
function originalNodesHaveSameParent(nodeA, nodeB) {
|
|
nodeA = getOriginalNode(nodeA);
|
|
return nodeA.parent && nodeA.parent === getOriginalNode(nodeB).parent;
|
|
}
|
|
function siblingNodePositionsAreComparable(previousNode, nextNode) {
|
|
if (nextNode.pos < previousNode.end) {
|
|
return false;
|
|
}
|
|
previousNode = getOriginalNode(previousNode);
|
|
nextNode = getOriginalNode(nextNode);
|
|
const parent = previousNode.parent;
|
|
if (!parent || parent !== nextNode.parent) {
|
|
return false;
|
|
}
|
|
const parentNodeArray = getContainingNodeArray(previousNode);
|
|
const prevNodeIndex = parentNodeArray == null ? void 0 : parentNodeArray.indexOf(previousNode);
|
|
return prevNodeIndex !== void 0 && prevNodeIndex > -1 && parentNodeArray.indexOf(nextNode) === prevNodeIndex + 1;
|
|
}
|
|
function emitLeadingComments(pos, isEmittedNode) {
|
|
hasWrittenComment = false;
|
|
if (isEmittedNode) {
|
|
if (pos === 0 && (currentSourceFile == null ? void 0 : currentSourceFile.isDeclarationFile)) {
|
|
forEachLeadingCommentToEmit(pos, emitNonTripleSlashLeadingComment);
|
|
} else {
|
|
forEachLeadingCommentToEmit(pos, emitLeadingComment);
|
|
}
|
|
} else if (pos === 0) {
|
|
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 isJSDocLikeText(text, pos) || isPinnedComment(text, pos);
|
|
}
|
|
return true;
|
|
}
|
|
function emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
if (!hasWrittenComment) {
|
|
emitNewLineBeforeLeadingCommentOfPosition(getCurrentLineMap(), writer, rangePos, commentPos);
|
|
hasWrittenComment = true;
|
|
}
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
} else if (kind === 3 /* MultiLineCommentTrivia */) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function emitLeadingCommentsOfPosition(pos) {
|
|
if (commentsDisabled || pos === -1) {
|
|
return;
|
|
}
|
|
emitLeadingComments(pos, true);
|
|
}
|
|
function emitTrailingComments(pos) {
|
|
forEachTrailingCommentToEmit(pos, emitTrailingComment);
|
|
}
|
|
function emitTrailingComment(commentPos, commentEnd, _kind, hasTrailingNewLine) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
if (!writer.isAtStartOfLine()) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
emitPos(commentPos);
|
|
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;
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) {
|
|
if (!currentSourceFile)
|
|
return;
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
} else {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function forEachLeadingCommentToEmit(pos, cb) {
|
|
if (currentSourceFile && (containerPos === -1 || pos !== containerPos)) {
|
|
if (hasDetachedComments(pos)) {
|
|
forEachLeadingCommentWithoutDetachedComments(cb);
|
|
} else {
|
|
forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos);
|
|
}
|
|
}
|
|
}
|
|
function forEachTrailingCommentToEmit(end, cb) {
|
|
if (currentSourceFile && (containerEnd === -1 || end !== containerEnd && end !== declarationListContainerEnd)) {
|
|
forEachTrailingCommentRange(currentSourceFile.text, end, cb);
|
|
}
|
|
}
|
|
function hasDetachedComments(pos) {
|
|
return detachedCommentsInfo !== void 0 && last(detachedCommentsInfo).nodePos === pos;
|
|
}
|
|
function forEachLeadingCommentWithoutDetachedComments(cb) {
|
|
if (!currentSourceFile)
|
|
return;
|
|
const pos = last(detachedCommentsInfo).detachedCommentEndPos;
|
|
if (detachedCommentsInfo.length - 1) {
|
|
detachedCommentsInfo.pop();
|
|
} else {
|
|
detachedCommentsInfo = void 0;
|
|
}
|
|
forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos);
|
|
}
|
|
function emitDetachedCommentsAndUpdateCommentsInfo(range) {
|
|
const currentDetachedCommentInfo = currentSourceFile && emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled);
|
|
if (currentDetachedCommentInfo) {
|
|
if (detachedCommentsInfo) {
|
|
detachedCommentsInfo.push(currentDetachedCommentInfo);
|
|
} else {
|
|
detachedCommentsInfo = [currentDetachedCommentInfo];
|
|
}
|
|
}
|
|
}
|
|
function emitComment(text, lineMap, writer2, commentPos, commentEnd, newLine2) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
emitPos(commentPos);
|
|
writeCommentRange(text, lineMap, writer2, commentPos, commentEnd, newLine2);
|
|
emitPos(commentEnd);
|
|
}
|
|
function isTripleSlashComment(commentPos, commentEnd) {
|
|
return !!currentSourceFile && isRecognizedTripleSlashComment(currentSourceFile.text, commentPos, commentEnd);
|
|
}
|
|
function getParsedSourceMap(node) {
|
|
if (node.parsedSourceMap === void 0 && node.sourceMapText !== void 0) {
|
|
node.parsedSourceMap = tryParseRawSourceMap(node.sourceMapText) || false;
|
|
}
|
|
return node.parsedSourceMap || void 0;
|
|
}
|
|
function pipelineEmitWithSourceMaps(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(3 /* SourceMaps */, hint, node);
|
|
emitSourceMapsBeforeNode(node);
|
|
pipelinePhase(hint, node);
|
|
emitSourceMapsAfterNode(node);
|
|
}
|
|
function emitSourceMapsBeforeNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
if (isUnparsedNode(node)) {
|
|
Debug.assertIsDefined(node.parent, "UnparsedNodes must have parent pointers");
|
|
const 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 {
|
|
const source = sourceMapRange.source || sourceMapSource;
|
|
if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 32 /* NoLeadingSourceMap */) === 0 && sourceMapRange.pos >= 0) {
|
|
emitSourcePos(sourceMapRange.source || sourceMapSource, skipSourceTrivia(source, sourceMapRange.pos));
|
|
}
|
|
if (emitFlags & 128 /* NoNestedSourceMaps */) {
|
|
sourceMapsDisabled = true;
|
|
}
|
|
}
|
|
}
|
|
function emitSourceMapsAfterNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
if (!isUnparsedNode(node)) {
|
|
if (emitFlags & 128 /* NoNestedSourceMaps */) {
|
|
sourceMapsDisabled = false;
|
|
}
|
|
if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 64 /* NoTrailingSourceMap */) === 0 && sourceMapRange.end >= 0) {
|
|
emitSourcePos(sourceMapRange.source || sourceMapSource, sourceMapRange.end);
|
|
}
|
|
}
|
|
}
|
|
function skipSourceTrivia(source, pos) {
|
|
return source.skipTrivia ? source.skipTrivia(pos) : skipTrivia(source.text, pos);
|
|
}
|
|
function emitPos(pos) {
|
|
if (sourceMapsDisabled || positionIsSynthesized(pos) || isJsonSourceMapSource(sourceMapSource)) {
|
|
return;
|
|
}
|
|
const { line: sourceLine, character: sourceCharacter } = getLineAndCharacterOfPosition(sourceMapSource, pos);
|
|
sourceMapGenerator.addMapping(
|
|
writer.getLine(),
|
|
writer.getColumn(),
|
|
sourceMapSourceIndex,
|
|
sourceLine,
|
|
sourceCharacter,
|
|
void 0
|
|
);
|
|
}
|
|
function emitSourcePos(source, pos) {
|
|
if (source !== sourceMapSource) {
|
|
const savedSourceMapSource = sourceMapSource;
|
|
const savedSourceMapSourceIndex = sourceMapSourceIndex;
|
|
setSourceMapSource(source);
|
|
emitPos(pos);
|
|
resetSourceMapSource(savedSourceMapSource, savedSourceMapSourceIndex);
|
|
} else {
|
|
emitPos(pos);
|
|
}
|
|
}
|
|
function emitTokenWithSourceMap(node, token, writer2, tokenPos, emitCallback) {
|
|
if (sourceMapsDisabled || node && isInJsonFile(node)) {
|
|
return emitCallback(token, writer2, tokenPos);
|
|
}
|
|
const emitNode = node && node.emitNode;
|
|
const emitFlags = emitNode && emitNode.flags || 0 /* None */;
|
|
const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
|
|
const source = range && range.source || sourceMapSource;
|
|
tokenPos = skipSourceTrivia(source, range ? range.pos : tokenPos);
|
|
if ((emitFlags & 256 /* NoTokenLeadingSourceMaps */) === 0 && tokenPos >= 0) {
|
|
emitSourcePos(source, tokenPos);
|
|
}
|
|
tokenPos = emitCallback(token, writer2, tokenPos);
|
|
if (range)
|
|
tokenPos = range.end;
|
|
if ((emitFlags & 512 /* NoTokenTrailingSourceMaps */) === 0 && tokenPos >= 0) {
|
|
emitSourcePos(source, tokenPos);
|
|
}
|
|
return tokenPos;
|
|
}
|
|
function setSourceMapSource(source) {
|
|
if (sourceMapsDisabled) {
|
|
return;
|
|
}
|
|
sourceMapSource = source;
|
|
if (source === mostRecentlyAddedSourceMapSource) {
|
|
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 fileExtensionIs(sourceFile.fileName, ".json" /* Json */);
|
|
}
|
|
}
|
|
function createBracketsMap() {
|
|
const brackets2 = [];
|
|
brackets2[1024 /* Braces */] = ["{", "}"];
|
|
brackets2[2048 /* Parenthesis */] = ["(", ")"];
|
|
brackets2[4096 /* AngleBrackets */] = ["<", ">"];
|
|
brackets2[8192 /* SquareBrackets */] = ["[", "]"];
|
|
return brackets2;
|
|
}
|
|
function getOpeningBracket(format) {
|
|
return brackets[format & 15360 /* BracketsMask */][0];
|
|
}
|
|
function getClosingBracket(format) {
|
|
return brackets[format & 15360 /* BracketsMask */][1];
|
|
}
|
|
var TempFlags = /* @__PURE__ */ ((TempFlags2) => {
|
|
TempFlags2[TempFlags2["Auto"] = 0] = "Auto";
|
|
TempFlags2[TempFlags2["CountMask"] = 268435455] = "CountMask";
|
|
TempFlags2[TempFlags2["_i"] = 268435456] = "_i";
|
|
return TempFlags2;
|
|
})(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;
|
|
}
|
|
|
|
// src/compiler/watchUtilities.ts
|
|
function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames) {
|
|
if (!host.getDirectories || !host.readDirectory) {
|
|
return void 0;
|
|
}
|
|
const cachedReadDirectoryResult = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return {
|
|
useCaseSensitiveFileNames,
|
|
fileExists,
|
|
readFile: (path, encoding) => host.readFile(path, encoding),
|
|
directoryExists: host.directoryExists && directoryExists,
|
|
getDirectories,
|
|
readDirectory,
|
|
createDirectory: host.createDirectory && createDirectory,
|
|
writeFile: host.writeFile && writeFile2,
|
|
addOrDeleteFileOrDirectory,
|
|
addOrDeleteFile,
|
|
clearCache,
|
|
realpath: host.realpath && realpath
|
|
};
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function getCachedFileSystemEntries(rootDirPath) {
|
|
return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
|
|
}
|
|
function getCachedFileSystemEntriesForBaseDir(path) {
|
|
const entries = getCachedFileSystemEntries(getDirectoryPath(path));
|
|
if (!entries) {
|
|
return entries;
|
|
}
|
|
if (!entries.sortedAndCanonicalizedFiles) {
|
|
entries.sortedAndCanonicalizedFiles = entries.files.map(getCanonicalFileName).sort();
|
|
entries.sortedAndCanonicalizedDirectories = entries.directories.map(getCanonicalFileName).sort();
|
|
}
|
|
return entries;
|
|
}
|
|
function getBaseNameOfFileName(fileName) {
|
|
return getBaseFileName(normalizePath(fileName));
|
|
}
|
|
function createCachedFileSystemEntries(rootDir, rootDirPath) {
|
|
var _a2;
|
|
if (!host.realpath || ensureTrailingDirectorySeparator(toPath3(host.realpath(rootDir))) === rootDirPath) {
|
|
const resultFromHost = {
|
|
files: map(host.readDirectory(rootDir, void 0, void 0, ["*.*"]), getBaseNameOfFileName) || [],
|
|
directories: host.getDirectories(rootDir) || []
|
|
};
|
|
cachedReadDirectoryResult.set(ensureTrailingDirectorySeparator(rootDirPath), resultFromHost);
|
|
return resultFromHost;
|
|
}
|
|
if ((_a2 = host.directoryExists) == null ? void 0 : _a2.call(host, rootDir)) {
|
|
cachedReadDirectoryResult.set(rootDirPath, false);
|
|
return false;
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryReadDirectory(rootDir, rootDirPath) {
|
|
rootDirPath = ensureTrailingDirectorySeparator(rootDirPath);
|
|
const cachedResult = getCachedFileSystemEntries(rootDirPath);
|
|
if (cachedResult) {
|
|
return cachedResult;
|
|
}
|
|
try {
|
|
return createCachedFileSystemEntries(rootDir, rootDirPath);
|
|
} catch (_e) {
|
|
Debug.assert(!cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(rootDirPath)));
|
|
return void 0;
|
|
}
|
|
}
|
|
function hasEntry(entries, name) {
|
|
const index = binarySearch(entries, name, identity, compareStringsCaseSensitive);
|
|
return index >= 0;
|
|
}
|
|
function writeFile2(fileName, data, writeByteOrderMark) {
|
|
const path = toPath3(fileName);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
if (result) {
|
|
updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), true);
|
|
}
|
|
return host.writeFile(fileName, data, writeByteOrderMark);
|
|
}
|
|
function fileExists(fileName) {
|
|
const path = toPath3(fileName);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
|
|
}
|
|
function directoryExists(dirPath) {
|
|
const path = toPath3(dirPath);
|
|
return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path)) || host.directoryExists(dirPath);
|
|
}
|
|
function createDirectory(dirPath) {
|
|
const path = toPath3(dirPath);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
if (result) {
|
|
const baseName = getBaseNameOfFileName(dirPath);
|
|
const canonicalizedBaseName = getCanonicalFileName(baseName);
|
|
const canonicalizedDirectories = result.sortedAndCanonicalizedDirectories;
|
|
if (insertSorted(canonicalizedDirectories, canonicalizedBaseName, compareStringsCaseSensitive)) {
|
|
result.directories.push(baseName);
|
|
}
|
|
}
|
|
host.createDirectory(dirPath);
|
|
}
|
|
function getDirectories(rootDir) {
|
|
const rootDirPath = toPath3(rootDir);
|
|
const result = tryReadDirectory(rootDir, rootDirPath);
|
|
if (result) {
|
|
return result.directories.slice();
|
|
}
|
|
return host.getDirectories(rootDir);
|
|
}
|
|
function readDirectory(rootDir, extensions, excludes, includes, depth) {
|
|
const rootDirPath = toPath3(rootDir);
|
|
const rootResult = tryReadDirectory(rootDir, rootDirPath);
|
|
let rootSymLinkResult;
|
|
if (rootResult !== void 0) {
|
|
return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
|
|
}
|
|
return host.readDirectory(rootDir, extensions, excludes, includes, depth);
|
|
function getFileSystemEntries(dir) {
|
|
const path = toPath3(dir);
|
|
if (path === rootDirPath) {
|
|
return rootResult || getFileSystemEntriesFromHost(dir, path);
|
|
}
|
|
const result = tryReadDirectory(dir, path);
|
|
return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path) : emptyFileSystemEntries;
|
|
}
|
|
function getFileSystemEntriesFromHost(dir, path) {
|
|
if (rootSymLinkResult && path === rootDirPath)
|
|
return rootSymLinkResult;
|
|
const result = {
|
|
files: map(host.readDirectory(dir, void 0, void 0, ["*.*"]), getBaseNameOfFileName) || emptyArray,
|
|
directories: host.getDirectories(dir) || emptyArray
|
|
};
|
|
if (path === rootDirPath)
|
|
rootSymLinkResult = result;
|
|
return result;
|
|
}
|
|
}
|
|
function realpath(s) {
|
|
return host.realpath ? host.realpath(s) : s;
|
|
}
|
|
function addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath) {
|
|
const existingResult = getCachedFileSystemEntries(fileOrDirectoryPath);
|
|
if (existingResult !== void 0) {
|
|
clearCache();
|
|
return void 0;
|
|
}
|
|
const parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath);
|
|
if (!parentResult) {
|
|
return void 0;
|
|
}
|
|
if (!host.directoryExists) {
|
|
clearCache();
|
|
return void 0;
|
|
}
|
|
const baseName = getBaseNameOfFileName(fileOrDirectory);
|
|
const fsQueryResult = {
|
|
fileExists: host.fileExists(fileOrDirectoryPath),
|
|
directoryExists: host.directoryExists(fileOrDirectoryPath)
|
|
};
|
|
if (fsQueryResult.directoryExists || hasEntry(parentResult.sortedAndCanonicalizedDirectories, getCanonicalFileName(baseName))) {
|
|
clearCache();
|
|
} else {
|
|
updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists);
|
|
}
|
|
return fsQueryResult;
|
|
}
|
|
function addOrDeleteFile(fileName, filePath, eventKind) {
|
|
if (eventKind === 1 /* Changed */) {
|
|
return;
|
|
}
|
|
const parentResult = getCachedFileSystemEntriesForBaseDir(filePath);
|
|
if (parentResult) {
|
|
updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === 0 /* Created */);
|
|
}
|
|
}
|
|
function updateFilesOfFileSystemEntry(parentResult, baseName, fileExists2) {
|
|
const canonicalizedFiles = parentResult.sortedAndCanonicalizedFiles;
|
|
const canonicalizedBaseName = getCanonicalFileName(baseName);
|
|
if (fileExists2) {
|
|
if (insertSorted(canonicalizedFiles, canonicalizedBaseName, compareStringsCaseSensitive)) {
|
|
parentResult.files.push(baseName);
|
|
}
|
|
} else {
|
|
const sortedIndex = binarySearch(canonicalizedFiles, canonicalizedBaseName, identity, compareStringsCaseSensitive);
|
|
if (sortedIndex >= 0) {
|
|
canonicalizedFiles.splice(sortedIndex, 1);
|
|
const unsortedIndex = parentResult.files.findIndex((entry) => getCanonicalFileName(entry) === canonicalizedBaseName);
|
|
parentResult.files.splice(unsortedIndex, 1);
|
|
}
|
|
}
|
|
}
|
|
function clearCache() {
|
|
cachedReadDirectoryResult.clear();
|
|
}
|
|
}
|
|
function updateSharedExtendedConfigFileWatcher(projectPath, options, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath3) {
|
|
var _a2;
|
|
const extendedConfigs = arrayToMap(((_a2 = options == null ? void 0 : options.configFile) == null ? void 0 : _a2.extendedSourceFiles) || emptyArray, toPath3);
|
|
extendedConfigFilesMap.forEach((watcher, extendedConfigFilePath) => {
|
|
if (!extendedConfigs.has(extendedConfigFilePath)) {
|
|
watcher.projects.delete(projectPath);
|
|
watcher.close();
|
|
}
|
|
});
|
|
extendedConfigs.forEach((extendedConfigFileName, extendedConfigFilePath) => {
|
|
const existing = extendedConfigFilesMap.get(extendedConfigFilePath);
|
|
if (existing) {
|
|
existing.projects.add(projectPath);
|
|
} else {
|
|
extendedConfigFilesMap.set(extendedConfigFilePath, {
|
|
projects: /* @__PURE__ */ new Set([projectPath]),
|
|
watcher: createExtendedConfigFileWatch(extendedConfigFileName, extendedConfigFilePath),
|
|
close: () => {
|
|
const existing2 = extendedConfigFilesMap.get(extendedConfigFilePath);
|
|
if (!existing2 || existing2.projects.size !== 0)
|
|
return;
|
|
existing2.watcher.close();
|
|
extendedConfigFilesMap.delete(extendedConfigFilePath);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function clearSharedExtendedConfigFileWatcher(projectPath, extendedConfigFilesMap) {
|
|
extendedConfigFilesMap.forEach((watcher) => {
|
|
if (watcher.projects.delete(projectPath))
|
|
watcher.close();
|
|
});
|
|
}
|
|
function cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath3) {
|
|
if (!extendedConfigCache.delete(extendedConfigFilePath))
|
|
return;
|
|
extendedConfigCache.forEach(({ extendedResult }, key) => {
|
|
var _a2;
|
|
if ((_a2 = extendedResult.extendedSourceFiles) == null ? void 0 : _a2.some((extendedFile) => toPath3(extendedFile) === extendedConfigFilePath)) {
|
|
cleanExtendedConfigCache(extendedConfigCache, key, toPath3);
|
|
}
|
|
});
|
|
}
|
|
function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) {
|
|
const missingFilePaths = program.getMissingFilePaths();
|
|
const newMissingFilePathMap = arrayToMap(missingFilePaths, identity, returnTrue);
|
|
mutateMap(
|
|
missingFileWatches,
|
|
newMissingFilePathMap,
|
|
{
|
|
createNewValue: createMissingFileWatch,
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function updateWatchingWildcardDirectories(existingWatchedForWildcards, wildcardDirectories, watchDirectory) {
|
|
mutateMap(
|
|
existingWatchedForWildcards,
|
|
wildcardDirectories,
|
|
{
|
|
createNewValue: createWildcardDirectoryWatcher,
|
|
onDeleteValue: closeFileWatcherOf,
|
|
onExistingValue: updateWildcardDirectoryWatcher
|
|
}
|
|
);
|
|
function createWildcardDirectoryWatcher(directory, flags) {
|
|
return {
|
|
watcher: watchDirectory(directory, flags),
|
|
flags
|
|
};
|
|
}
|
|
function updateWildcardDirectoryWatcher(existingWatcher, flags, directory) {
|
|
if (existingWatcher.flags === flags) {
|
|
return;
|
|
}
|
|
existingWatcher.watcher.close();
|
|
existingWatchedForWildcards.set(directory, createWildcardDirectoryWatcher(directory, flags));
|
|
}
|
|
}
|
|
function isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath,
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName,
|
|
options,
|
|
program,
|
|
extraFileExtensions,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}) {
|
|
const newPath = removeIgnoredPath(fileOrDirectoryPath);
|
|
if (!newPath) {
|
|
writeLog(`Project: ${configFileName} Detected ignored path: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
fileOrDirectoryPath = newPath;
|
|
if (fileOrDirectoryPath === watchedDirPath)
|
|
return false;
|
|
if (hasExtension(fileOrDirectoryPath) && !isSupportedSourceFileName(fileOrDirectory, options, extraFileExtensions)) {
|
|
writeLog(`Project: ${configFileName} Detected file add/remove of non supported extension: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
if (isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) {
|
|
writeLog(`Project: ${configFileName} Detected excluded file: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
if (!program)
|
|
return false;
|
|
if (outFile(options) || options.outDir)
|
|
return false;
|
|
if (isDeclarationFileName(fileOrDirectoryPath)) {
|
|
if (options.declarationDir)
|
|
return false;
|
|
} else if (!fileExtensionIsOneOf(fileOrDirectoryPath, supportedJSExtensionsFlat)) {
|
|
return false;
|
|
}
|
|
const filePathWithoutExtension = removeFileExtension(fileOrDirectoryPath);
|
|
const realProgram = isArray(program) ? void 0 : isBuilderProgram(program) ? program.getProgramOrUndefined() : program;
|
|
const builderProgram = !realProgram && !isArray(program) ? program : void 0;
|
|
if (hasSourceFile(filePathWithoutExtension + ".ts" /* Ts */) || hasSourceFile(filePathWithoutExtension + ".tsx" /* Tsx */)) {
|
|
writeLog(`Project: ${configFileName} Detected output file: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
return false;
|
|
function hasSourceFile(file) {
|
|
return realProgram ? !!realProgram.getSourceFileByPath(file) : builderProgram ? builderProgram.getState().fileInfos.has(file) : !!find(program, (rootFile) => toPath3(rootFile) === file);
|
|
}
|
|
}
|
|
function isBuilderProgram(program) {
|
|
return !!program.getState;
|
|
}
|
|
function isEmittedFileOfProgram(program, file) {
|
|
if (!program) {
|
|
return false;
|
|
}
|
|
return program.isEmittedFile(file);
|
|
}
|
|
function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo) {
|
|
setSysLog(watchLogLevel === 2 /* Verbose */ ? log : noop);
|
|
const plainInvokeFactory = {
|
|
watchFile: (file, callback, pollingInterval, options) => host.watchFile(file, callback, pollingInterval, options),
|
|
watchDirectory: (directory, callback, flags, options) => host.watchDirectory(directory, callback, (flags & 1 /* Recursive */) !== 0, options)
|
|
};
|
|
const triggerInvokingFactory = watchLogLevel !== 0 /* None */ ? {
|
|
watchFile: createTriggerLoggingAddWatch("watchFile"),
|
|
watchDirectory: createTriggerLoggingAddWatch("watchDirectory")
|
|
} : void 0;
|
|
const factory2 = watchLogLevel === 2 /* Verbose */ ? {
|
|
watchFile: createFileWatcherWithLogging,
|
|
watchDirectory: createDirectoryWatcherWithLogging
|
|
} : triggerInvokingFactory || plainInvokeFactory;
|
|
const excludeWatcherFactory = watchLogLevel === 2 /* Verbose */ ? createExcludeWatcherWithLogging : returnNoopFileWatcher;
|
|
return {
|
|
watchFile: createExcludeHandlingAddWatch("watchFile"),
|
|
watchDirectory: createExcludeHandlingAddWatch("watchDirectory")
|
|
};
|
|
function createExcludeHandlingAddWatch(key) {
|
|
return (file, cb, flags, options, detailInfo1, detailInfo2) => {
|
|
var _a2;
|
|
return !matchesExclude(file, key === "watchFile" ? options == null ? void 0 : options.excludeFiles : options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames(), ((_a2 = host.getCurrentDirectory) == null ? void 0 : _a2.call(host)) || "") ? factory2[key].call(void 0, 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:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`);
|
|
return {
|
|
close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`)
|
|
};
|
|
}
|
|
function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
|
|
log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`);
|
|
const watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2);
|
|
return {
|
|
close: () => {
|
|
log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`);
|
|
watcher.close();
|
|
}
|
|
};
|
|
}
|
|
function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
|
|
const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`;
|
|
log(watchInfo);
|
|
const start = timestamp();
|
|
const watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2);
|
|
const elapsed = timestamp() - start;
|
|
log(`Elapsed:: ${elapsed}ms ${watchInfo}`);
|
|
return {
|
|
close: () => {
|
|
const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`;
|
|
log(watchInfo2);
|
|
const start2 = timestamp();
|
|
watcher.close();
|
|
const elapsed2 = timestamp() - start2;
|
|
log(`Elapsed:: ${elapsed2}ms ${watchInfo2}`);
|
|
}
|
|
};
|
|
}
|
|
function createTriggerLoggingAddWatch(key) {
|
|
return (file, cb, flags, options, detailInfo1, detailInfo2) => plainInvokeFactory[key].call(void 0, file, (...args) => {
|
|
const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)}`;
|
|
log(triggerredInfo);
|
|
const start = timestamp();
|
|
cb.call(void 0, ...args);
|
|
const elapsed = timestamp() - start;
|
|
log(`Elapsed:: ${elapsed}ms ${triggerredInfo}`);
|
|
}, flags, options, detailInfo1, detailInfo2);
|
|
}
|
|
function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2) {
|
|
return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo2 ? getDetailWatchInfo2(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`;
|
|
}
|
|
}
|
|
function getFallbackOptions(options) {
|
|
const fallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchFile: fallbackPolling !== void 0 ? fallbackPolling : 1 /* PriorityPollingInterval */
|
|
};
|
|
}
|
|
function closeFileWatcherOf(objWithWatcher) {
|
|
objWithWatcher.watcher.close();
|
|
}
|
|
|
|
// src/compiler/program.ts
|
|
function findConfigFile(searchPath, fileExists, configName = "tsconfig.json") {
|
|
return forEachAncestorDirectory(searchPath, (ancestor) => {
|
|
const fileName = combinePaths(ancestor, configName);
|
|
return fileExists(fileName) ? fileName : void 0;
|
|
});
|
|
}
|
|
function resolveTripleslashReference(moduleName, containingFile) {
|
|
const basePath = getDirectoryPath(containingFile);
|
|
const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);
|
|
return normalizePath(referencedFileName);
|
|
}
|
|
function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) {
|
|
let commonPathComponents;
|
|
const failed = forEach(fileNames, (sourceFile) => {
|
|
const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory);
|
|
sourcePathComponents.pop();
|
|
if (!commonPathComponents) {
|
|
commonPathComponents = sourcePathComponents;
|
|
return;
|
|
}
|
|
const n = Math.min(commonPathComponents.length, sourcePathComponents.length);
|
|
for (let i = 0; i < n; i++) {
|
|
if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {
|
|
if (i === 0) {
|
|
return true;
|
|
}
|
|
commonPathComponents.length = i;
|
|
break;
|
|
}
|
|
}
|
|
if (sourcePathComponents.length < commonPathComponents.length) {
|
|
commonPathComponents.length = sourcePathComponents.length;
|
|
}
|
|
});
|
|
if (failed) {
|
|
return "";
|
|
}
|
|
if (!commonPathComponents) {
|
|
return currentDirectory;
|
|
}
|
|
return getPathFromPathComponents(commonPathComponents);
|
|
}
|
|
function createCompilerHost(options, setParentNodes) {
|
|
return createCompilerHostWorker(options, setParentNodes);
|
|
}
|
|
function createGetSourceFile(readFile, getCompilerOptions, setParentNodes) {
|
|
return (fileName, languageVersionOrOptions, onError) => {
|
|
let text;
|
|
try {
|
|
mark("beforeIORead");
|
|
text = readFile(fileName, getCompilerOptions().charset);
|
|
mark("afterIORead");
|
|
measure("I/O Read", "beforeIORead", "afterIORead");
|
|
} catch (e) {
|
|
if (onError) {
|
|
onError(e.message);
|
|
}
|
|
text = "";
|
|
}
|
|
return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : void 0;
|
|
};
|
|
}
|
|
function createWriteFileMeasuringIO(actualWriteFile, createDirectory, directoryExists) {
|
|
return (fileName, data, writeByteOrderMark, onError) => {
|
|
try {
|
|
mark("beforeIOWrite");
|
|
writeFileEnsuringDirectories(
|
|
fileName,
|
|
data,
|
|
writeByteOrderMark,
|
|
actualWriteFile,
|
|
createDirectory,
|
|
directoryExists
|
|
);
|
|
mark("afterIOWrite");
|
|
measure("I/O Write", "beforeIOWrite", "afterIOWrite");
|
|
} catch (e) {
|
|
if (onError) {
|
|
onError(e.message);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function createCompilerHostWorker(options, setParentNodes, system = sys) {
|
|
const existingDirectories = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
|
|
function directoryExists(directoryPath) {
|
|
if (existingDirectories.has(directoryPath)) {
|
|
return true;
|
|
}
|
|
if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
|
|
existingDirectories.set(directoryPath, true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getDefaultLibLocation() {
|
|
return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
|
|
}
|
|
const newLine = getNewLineCharacter(options, () => system.newLine);
|
|
const realpath = system.realpath && ((path) => system.realpath(path));
|
|
const compilerHost = {
|
|
getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), () => options, setParentNodes),
|
|
getDefaultLibLocation,
|
|
getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
|
|
writeFile: createWriteFileMeasuringIO(
|
|
(path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
|
|
(path) => (compilerHost.createDirectory || system.createDirectory)(path),
|
|
(path) => directoryExists(path)
|
|
),
|
|
getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
|
|
useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
|
|
getCanonicalFileName,
|
|
getNewLine: () => newLine,
|
|
fileExists: (fileName) => system.fileExists(fileName),
|
|
readFile: (fileName) => system.readFile(fileName),
|
|
trace: (s) => system.write(s + newLine),
|
|
directoryExists: (directoryName) => system.directoryExists(directoryName),
|
|
getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
|
|
getDirectories: (path) => system.getDirectories(path),
|
|
realpath,
|
|
readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
|
|
createDirectory: (d) => system.createDirectory(d),
|
|
createHash: maybeBind(system, system.createHash)
|
|
};
|
|
return compilerHost;
|
|
}
|
|
function changeCompilerHostLikeToUseCache(host, toPath3, getSourceFile) {
|
|
const originalReadFile = host.readFile;
|
|
const originalFileExists = host.fileExists;
|
|
const originalDirectoryExists = host.directoryExists;
|
|
const originalCreateDirectory = host.createDirectory;
|
|
const originalWriteFile = host.writeFile;
|
|
const readFileCache = /* @__PURE__ */ new Map();
|
|
const fileExistsCache = /* @__PURE__ */ new Map();
|
|
const directoryExistsCache = /* @__PURE__ */ new Map();
|
|
const sourceFileCache = /* @__PURE__ */ new Map();
|
|
const readFileWithCache = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0)
|
|
return value !== false ? value : void 0;
|
|
return setReadFileCache(key, fileName);
|
|
};
|
|
const setReadFileCache = (key, fileName) => {
|
|
const newValue = originalReadFile.call(host, fileName);
|
|
readFileCache.set(key, newValue !== void 0 ? newValue : false);
|
|
return newValue;
|
|
};
|
|
host.readFile = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0)
|
|
return value !== false ? value : void 0;
|
|
if (!fileExtensionIs(fileName, ".json" /* Json */) && !isBuildInfoFile(fileName)) {
|
|
return originalReadFile.call(host, fileName);
|
|
}
|
|
return setReadFileCache(key, fileName);
|
|
};
|
|
const getSourceFileWithCache = getSourceFile ? (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
|
|
const key = toPath3(fileName);
|
|
const impliedNodeFormat = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : void 0;
|
|
const forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat);
|
|
const value = forImpliedNodeFormat == null ? void 0 : forImpliedNodeFormat.get(key);
|
|
if (value)
|
|
return value;
|
|
const sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
|
|
if (sourceFile && (isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".json" /* Json */))) {
|
|
sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || /* @__PURE__ */ new Map()).set(key, sourceFile));
|
|
}
|
|
return sourceFile;
|
|
} : void 0;
|
|
host.fileExists = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = fileExistsCache.get(key);
|
|
if (value !== void 0)
|
|
return value;
|
|
const newValue = originalFileExists.call(host, fileName);
|
|
fileExistsCache.set(key, !!newValue);
|
|
return newValue;
|
|
};
|
|
if (originalWriteFile) {
|
|
host.writeFile = (fileName, data, ...rest) => {
|
|
const key = toPath3(fileName);
|
|
fileExistsCache.delete(key);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0 && value !== data) {
|
|
readFileCache.delete(key);
|
|
sourceFileCache.forEach((map2) => map2.delete(key));
|
|
} else if (getSourceFileWithCache) {
|
|
sourceFileCache.forEach((map2) => {
|
|
const sourceFile = map2.get(key);
|
|
if (sourceFile && sourceFile.text !== data) {
|
|
map2.delete(key);
|
|
}
|
|
});
|
|
}
|
|
originalWriteFile.call(host, fileName, data, ...rest);
|
|
};
|
|
}
|
|
if (originalDirectoryExists) {
|
|
host.directoryExists = (directory) => {
|
|
const key = toPath3(directory);
|
|
const value = directoryExistsCache.get(key);
|
|
if (value !== void 0)
|
|
return value;
|
|
const newValue = originalDirectoryExists.call(host, directory);
|
|
directoryExistsCache.set(key, !!newValue);
|
|
return newValue;
|
|
};
|
|
if (originalCreateDirectory) {
|
|
host.createDirectory = (directory) => {
|
|
const key = toPath3(directory);
|
|
directoryExistsCache.delete(key);
|
|
originalCreateDirectory.call(host, directory);
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
getSourceFileWithCache,
|
|
readFileWithCache
|
|
};
|
|
}
|
|
function formatDiagnostic(diagnostic, host) {
|
|
const errorMessage = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;
|
|
if (diagnostic.file) {
|
|
const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
|
|
const fileName = diagnostic.file.fileName;
|
|
const relativeFileName = convertToRelativePath(fileName, host.getCurrentDirectory(), (fileName2) => host.getCanonicalFileName(fileName2));
|
|
return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage;
|
|
}
|
|
return errorMessage;
|
|
}
|
|
var gutterStyleSequence = "\x1B[7m";
|
|
var gutterSeparator = " ";
|
|
var resetEscapeSequence = "\x1B[0m";
|
|
var ellipsis = "...";
|
|
var halfIndent = " ";
|
|
var indent = " ";
|
|
function getCategoryFormat(category) {
|
|
switch (category) {
|
|
case 1 /* Error */:
|
|
return "\x1B[91m" /* Red */;
|
|
case 0 /* Warning */:
|
|
return "\x1B[93m" /* Yellow */;
|
|
case 2 /* Suggestion */:
|
|
return Debug.fail("Should never get an Info diagnostic on the command line.");
|
|
case 3 /* Message */:
|
|
return "\x1B[94m" /* Blue */;
|
|
}
|
|
}
|
|
function formatColorAndReset(text, formatStyle) {
|
|
return formatStyle + text + resetEscapeSequence;
|
|
}
|
|
function formatCodeSpan(file, start, length2, indent2, squiggleColor, host) {
|
|
const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);
|
|
const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start + length2);
|
|
const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;
|
|
const hasMoreThanFiveLines = lastLine - firstLine >= 4;
|
|
let gutterWidth = (lastLine + 1 + "").length;
|
|
if (hasMoreThanFiveLines) {
|
|
gutterWidth = Math.max(ellipsis.length, gutterWidth);
|
|
}
|
|
let context = "";
|
|
for (let i = firstLine; i <= lastLine; i++) {
|
|
context += host.getNewLine();
|
|
if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
|
|
context += indent2 + formatColorAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine();
|
|
i = lastLine - 1;
|
|
}
|
|
const lineStart = getPositionOfLineAndCharacter(file, i, 0);
|
|
const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;
|
|
let lineContent = file.text.slice(lineStart, lineEnd);
|
|
lineContent = trimStringEnd(lineContent);
|
|
lineContent = lineContent.replace(/\t/g, " ");
|
|
context += indent2 + formatColorAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;
|
|
context += lineContent + host.getNewLine();
|
|
context += indent2 + formatColorAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;
|
|
context += squiggleColor;
|
|
if (i === firstLine) {
|
|
const lastCharForLine = i === lastLine ? lastLineChar : void 0;
|
|
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 {
|
|
context += lineContent.replace(/./g, "~");
|
|
}
|
|
context += resetEscapeSequence;
|
|
}
|
|
return context;
|
|
}
|
|
function formatLocation(file, start, host, color = formatColorAndReset) {
|
|
const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);
|
|
const relativeFileName = host ? convertToRelativePath(file.fileName, host.getCurrentDirectory(), (fileName) => host.getCanonicalFileName(fileName)) : file.fileName;
|
|
let output = "";
|
|
output += color(relativeFileName, "\x1B[96m" /* Cyan */);
|
|
output += ":";
|
|
output += color(`${firstLine + 1}`, "\x1B[93m" /* Yellow */);
|
|
output += ":";
|
|
output += color(`${firstLineChar + 1}`, "\x1B[93m" /* Yellow */);
|
|
return output;
|
|
}
|
|
function formatDiagnosticsWithColorAndContext(diagnostics, host) {
|
|
let output = "";
|
|
for (const diagnostic of diagnostics) {
|
|
if (diagnostic.file) {
|
|
const { file, start } = diagnostic;
|
|
output += formatLocation(file, start, host);
|
|
output += " - ";
|
|
}
|
|
output += formatColorAndReset(diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category));
|
|
output += formatColorAndReset(` TS${diagnostic.code}: `, "\x1B[90m" /* 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);
|
|
}
|
|
if (diagnostic.relatedInformation) {
|
|
output += host.getNewLine();
|
|
for (const { file, start, length: length2, messageText } of diagnostic.relatedInformation) {
|
|
if (file) {
|
|
output += host.getNewLine();
|
|
output += halfIndent + formatLocation(file, start, host);
|
|
output += formatCodeSpan(file, start, length2, indent, "\x1B[96m" /* Cyan */, host);
|
|
}
|
|
output += host.getNewLine();
|
|
output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine());
|
|
}
|
|
}
|
|
output += host.getNewLine();
|
|
}
|
|
return output;
|
|
}
|
|
function flattenDiagnosticMessageText(diag2, newLine, indent2 = 0) {
|
|
if (isString(diag2)) {
|
|
return diag2;
|
|
} else if (diag2 === void 0) {
|
|
return "";
|
|
}
|
|
let result = "";
|
|
if (indent2) {
|
|
result += newLine;
|
|
for (let i = 0; i < indent2; i++) {
|
|
result += " ";
|
|
}
|
|
}
|
|
result += diag2.messageText;
|
|
indent2++;
|
|
if (diag2.next) {
|
|
for (const kid of diag2.next) {
|
|
result += flattenDiagnosticMessageText(kid, newLine, indent2);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) {
|
|
if (names.length === 0) {
|
|
return [];
|
|
}
|
|
const resolutions = [];
|
|
const cache = /* @__PURE__ */ new Map();
|
|
for (const name of names) {
|
|
let result;
|
|
const mode = getModeForFileReference(name, containingFileMode);
|
|
const strName = getResolutionName(name);
|
|
const cacheKey = mode !== void 0 ? `${mode}|${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;
|
|
}
|
|
function getModeForFileReference(ref, containingFileMode) {
|
|
return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
|
|
}
|
|
function getModeForResolutionAtIndex(file, index) {
|
|
if (file.impliedNodeFormat === void 0)
|
|
return void 0;
|
|
return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index));
|
|
}
|
|
function isExclusivelyTypeOnlyImportOrExport(decl) {
|
|
var _a2;
|
|
if (isExportDeclaration(decl)) {
|
|
return decl.isTypeOnly;
|
|
}
|
|
if ((_a2 = decl.importClause) == null ? void 0 : _a2.isTypeOnly) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getModeForUsageLocation(file, usage) {
|
|
var _a2, _b;
|
|
if (file.impliedNodeFormat === void 0)
|
|
return void 0;
|
|
if (isImportDeclaration(usage.parent) || isExportDeclaration(usage.parent)) {
|
|
const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent);
|
|
if (isTypeOnly) {
|
|
const override = getResolutionModeOverrideForClause(usage.parent.assertClause);
|
|
if (override) {
|
|
return override;
|
|
}
|
|
}
|
|
}
|
|
if (usage.parent.parent && isImportTypeNode(usage.parent.parent)) {
|
|
const override = getResolutionModeOverrideForClause((_a2 = usage.parent.parent.assertions) == null ? void 0 : _a2.assertClause);
|
|
if (override) {
|
|
return override;
|
|
}
|
|
}
|
|
if (file.impliedNodeFormat !== 99 /* ESNext */) {
|
|
return isImportCall(walkUpParenthesizedExpressions(usage.parent)) ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
}
|
|
const exprParentParent = (_b = walkUpParenthesizedExpressions(usage.parent)) == null ? void 0 : _b.parent;
|
|
return exprParentParent && isImportEqualsDeclaration(exprParentParent) ? 1 /* CommonJS */ : 99 /* ESNext */;
|
|
}
|
|
function getResolutionModeOverrideForClause(clause, grammarErrorOnNode) {
|
|
if (!clause)
|
|
return void 0;
|
|
if (length(clause.elements) !== 1) {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(clause, Diagnostics.Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require);
|
|
return void 0;
|
|
}
|
|
const elem = clause.elements[0];
|
|
if (!isStringLiteralLike(elem.name))
|
|
return void 0;
|
|
if (elem.name.text !== "resolution-mode") {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(elem.name, Diagnostics.resolution_mode_is_the_only_valid_key_for_type_import_assertions);
|
|
return void 0;
|
|
}
|
|
if (!isStringLiteralLike(elem.value))
|
|
return void 0;
|
|
if (elem.value.text !== "import" && elem.value.text !== "require") {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(elem.value, Diagnostics.resolution_mode_should_be_either_require_or_import);
|
|
return void 0;
|
|
}
|
|
return elem.value.text === "import" ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
}
|
|
function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, resolutionInfo, loader) {
|
|
if (names.length === 0) {
|
|
return [];
|
|
}
|
|
const resolutions = [];
|
|
const cache = /* @__PURE__ */ new Map();
|
|
let i = 0;
|
|
for (const entry of resolutionInfo ? resolutionInfo.names : names) {
|
|
let result;
|
|
const mode = !isString(entry) ? getModeForUsageLocation(containingFile, entry) : getModeForResolutionAtIndex(containingFile, i);
|
|
i++;
|
|
const name = isString(entry) ? entry : entry.text;
|
|
const cacheKey = mode !== void 0 ? `${mode}|${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;
|
|
}
|
|
function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
|
|
return forEachProjectReference(void 0, resolvedProjectReferences, (resolvedRef, parent) => resolvedRef && cb(resolvedRef, parent));
|
|
}
|
|
function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
|
|
let seenResolvedRefs;
|
|
return worker(projectReferences, resolvedProjectReferences, void 0);
|
|
function worker(projectReferences2, resolvedProjectReferences2, parent) {
|
|
if (cbRef) {
|
|
const result = cbRef(projectReferences2, parent);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return forEach(resolvedProjectReferences2, (resolvedRef, index) => {
|
|
if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) {
|
|
return void 0;
|
|
}
|
|
const result = cbResolvedRef(resolvedRef, parent, index);
|
|
if (result || !resolvedRef)
|
|
return result;
|
|
(seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path);
|
|
return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef);
|
|
});
|
|
}
|
|
}
|
|
var inferredTypesContainingFile = "__inferred type names__.ts";
|
|
function isReferencedFile(reason) {
|
|
switch (reason == null ? void 0 : reason.kind) {
|
|
case 3 /* Import */:
|
|
case 4 /* ReferenceFile */:
|
|
case 5 /* TypeReferenceDirective */:
|
|
case 7 /* LibReferenceDirective */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isReferenceFileLocation(location) {
|
|
return location.pos !== void 0;
|
|
}
|
|
function getReferencedFileLocation(getSourceFileByPath, ref) {
|
|
var _a2, _b, _c, _d;
|
|
const file = Debug.checkDefined(getSourceFileByPath(ref.file));
|
|
const { kind, index } = ref;
|
|
let pos, end, packageId, resolutionMode;
|
|
switch (kind) {
|
|
case 3 /* Import */:
|
|
const importLiteral = getModuleNameStringLiteralAt(file, index);
|
|
packageId = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.packageId;
|
|
if (importLiteral.pos === -1)
|
|
return { file, packageId, text: importLiteral.text };
|
|
pos = skipTrivia(file.text, importLiteral.pos);
|
|
end = importLiteral.end;
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
({ pos, end } = file.referencedFiles[index]);
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
({ pos, end, resolutionMode } = file.typeReferenceDirectives[index]);
|
|
packageId = (_d = (_c = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _c.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _d.packageId;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
({ pos, end } = file.libReferenceDirectives[index]);
|
|
break;
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
return { file, pos, end, packageId };
|
|
}
|
|
function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
|
|
if (!program || (hasChangedAutomaticTypeDirectiveNames == null ? void 0 : hasChangedAutomaticTypeDirectiveNames()))
|
|
return false;
|
|
if (!arrayIsEqualTo(program.getRootFileNames(), rootFileNames))
|
|
return false;
|
|
let seenResolvedRefs;
|
|
if (!arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate))
|
|
return false;
|
|
if (program.getSourceFiles().some(sourceFileNotUptoDate))
|
|
return false;
|
|
if (program.getMissingFilePaths().some(fileExists))
|
|
return false;
|
|
const currentOptions = program.getCompilerOptions();
|
|
if (!compareDataObjects(currentOptions, newOptions))
|
|
return false;
|
|
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 projectReferenceIsEqualTo(oldRef, newRef) && resolvedProjectReferenceUptoDate(program.getResolvedProjectReferences()[index], oldRef);
|
|
}
|
|
function resolvedProjectReferenceUptoDate(oldResolvedRef, oldRef) {
|
|
if (oldResolvedRef) {
|
|
if (contains(seenResolvedRefs, oldResolvedRef))
|
|
return true;
|
|
const refPath2 = resolveProjectReferencePath(oldRef);
|
|
const newParsedCommandLine = getParsedCommandLine(refPath2);
|
|
if (!newParsedCommandLine)
|
|
return false;
|
|
if (oldResolvedRef.commandLine.options.configFile !== newParsedCommandLine.options.configFile)
|
|
return false;
|
|
if (!arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newParsedCommandLine.fileNames))
|
|
return false;
|
|
(seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef);
|
|
return !forEach(oldResolvedRef.references, (childResolvedRef, index) => !resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences[index]));
|
|
}
|
|
const refPath = resolveProjectReferencePath(oldRef);
|
|
return !getParsedCommandLine(refPath);
|
|
}
|
|
}
|
|
function getConfigFileParsingDiagnostics(configFileParseResult) {
|
|
return configFileParseResult.options.configFile ? [...configFileParseResult.options.configFile.parseDiagnostics, ...configFileParseResult.errors] : configFileParseResult.errors;
|
|
}
|
|
function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) {
|
|
const result = getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options);
|
|
return typeof result === "object" ? result.impliedNodeFormat : result;
|
|
}
|
|
function getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options) {
|
|
switch (getEmitModuleResolutionKind(options)) {
|
|
case 3 /* Node16 */:
|
|
case 99 /* NodeNext */:
|
|
return fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".mjs" /* Mjs */]) ? 99 /* ESNext */ : fileExtensionIsOneOf(fileName, [".d.cts" /* Dcts */, ".cts" /* Cts */, ".cjs" /* Cjs */]) ? 1 /* CommonJS */ : fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */]) ? lookupFromPackageJson() : void 0;
|
|
default:
|
|
return void 0;
|
|
}
|
|
function lookupFromPackageJson() {
|
|
const state = getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
|
|
const packageJsonLocations = [];
|
|
state.failedLookupLocations = packageJsonLocations;
|
|
state.affectingLocations = packageJsonLocations;
|
|
const packageJsonScope = getPackageScopeForPath(fileName, state);
|
|
const impliedNodeFormat = (packageJsonScope == null ? void 0 : packageJsonScope.contents.packageJsonContent.type) === "module" ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
return { impliedNodeFormat, packageJsonLocations, packageJsonScope };
|
|
}
|
|
}
|
|
var plainJSErrors = /* @__PURE__ */ new Set([
|
|
Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
|
|
Diagnostics.A_module_cannot_have_multiple_default_exports.code,
|
|
Diagnostics.Another_export_default_is_here.code,
|
|
Diagnostics.The_first_export_default_is_here.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code,
|
|
Diagnostics.constructor_is_a_reserved_word.code,
|
|
Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode.code,
|
|
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,
|
|
Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
|
|
Diagnostics.Invalid_use_of_0_in_strict_mode.code,
|
|
Diagnostics.A_label_is_not_allowed_here.code,
|
|
Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
|
|
Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
|
|
Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code,
|
|
Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement.code,
|
|
Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name.code,
|
|
Diagnostics.A_class_member_cannot_have_the_0_keyword.code,
|
|
Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name.code,
|
|
Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement.code,
|
|
Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration.code,
|
|
Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context.code,
|
|
Diagnostics.A_destructuring_declaration_must_have_an_initializer.code,
|
|
Diagnostics.A_get_accessor_cannot_have_parameters.code,
|
|
Diagnostics.A_rest_element_cannot_contain_a_binding_pattern.code,
|
|
Diagnostics.A_rest_element_cannot_have_a_property_name.code,
|
|
Diagnostics.A_rest_element_cannot_have_an_initializer.code,
|
|
Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern.code,
|
|
Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
|
|
Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
|
|
Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
|
|
Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
|
|
Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
|
|
Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
|
|
Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
|
|
Diagnostics.An_export_declaration_cannot_have_modifiers.code,
|
|
Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
|
|
Diagnostics.An_import_declaration_cannot_have_modifiers.code,
|
|
Diagnostics.An_object_member_cannot_be_declared_optional.code,
|
|
Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code,
|
|
Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable.code,
|
|
Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause.code,
|
|
Diagnostics.Catch_clause_variable_cannot_have_an_initializer.code,
|
|
Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator.code,
|
|
Diagnostics.Classes_can_only_extend_a_single_class.code,
|
|
Diagnostics.Classes_may_not_have_a_field_named_constructor.code,
|
|
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,
|
|
Diagnostics.Duplicate_label_0.code,
|
|
Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments.code,
|
|
Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block.code,
|
|
Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression.code,
|
|
Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name.code,
|
|
Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array.code,
|
|
Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names.code,
|
|
Diagnostics.Jump_target_cannot_cross_function_boundary.code,
|
|
Diagnostics.Line_terminator_not_permitted_before_arrow.code,
|
|
Diagnostics.Modifiers_cannot_appear_here.code,
|
|
Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement.code,
|
|
Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement.code,
|
|
Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies.code,
|
|
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,
|
|
Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier.code,
|
|
Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain.code,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async.code,
|
|
Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer.code,
|
|
Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer.code,
|
|
Diagnostics.Trailing_comma_not_allowed.code,
|
|
Diagnostics.Variable_declaration_list_cannot_be_empty.code,
|
|
Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses.code,
|
|
Diagnostics._0_expected.code,
|
|
Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2.code,
|
|
Diagnostics._0_list_cannot_be_empty.code,
|
|
Diagnostics._0_modifier_already_seen.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_parameter.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind.code,
|
|
Diagnostics._0_modifier_cannot_be_used_here.code,
|
|
Diagnostics._0_modifier_must_precede_1_modifier.code,
|
|
Diagnostics.const_declarations_can_only_be_declared_inside_a_block.code,
|
|
Diagnostics.const_declarations_must_be_initialized.code,
|
|
Diagnostics.extends_clause_already_seen.code,
|
|
Diagnostics.let_declarations_can_only_be_declared_inside_a_block.code,
|
|
Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
|
|
Diagnostics.Class_constructor_may_not_be_a_generator.code,
|
|
Diagnostics.Class_constructor_may_not_be_an_accessor.code,
|
|
Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code
|
|
]);
|
|
function shouldProgramCreateNewSourceFiles(program, newOptions) {
|
|
if (!program)
|
|
return false;
|
|
return optionsHaveChanges(program.getCompilerOptions(), newOptions, sourceFileAffectingCompilerOptions);
|
|
}
|
|
function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics) {
|
|
return {
|
|
rootNames,
|
|
options,
|
|
host,
|
|
oldProgram,
|
|
configFileParsingDiagnostics
|
|
};
|
|
}
|
|
function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
|
|
const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
|
|
const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;
|
|
let { oldProgram } = createProgramOptions;
|
|
let processingDefaultLibFiles;
|
|
let processingOtherFiles;
|
|
let files;
|
|
let symlinks;
|
|
let commonSourceDirectory;
|
|
let typeChecker;
|
|
let classifiableNames;
|
|
const ambientModuleNameToUnmodifiedFileName = /* @__PURE__ */ new Map();
|
|
let fileReasons = createMultiMap();
|
|
const cachedBindAndCheckDiagnosticsForFile = {};
|
|
const cachedDeclarationDiagnosticsForFile = {};
|
|
let resolvedTypeReferenceDirectives = createModeAwareCache();
|
|
let fileProcessingDiagnostics;
|
|
const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
|
|
let currentNodeModulesDepth = 0;
|
|
const modulesWithElidedImports = /* @__PURE__ */ new Map();
|
|
const sourceFilesFoundSearchingNodeModules = /* @__PURE__ */ new Map();
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, true);
|
|
mark("beforeProgram");
|
|
const host = createProgramOptions.host || createCompilerHost(options);
|
|
const configParsingHost = parseConfigHostFromCompilerHostLike(host);
|
|
let skipDefaultLib = options.noLib;
|
|
const getDefaultLibraryFileName = memoize(() => host.getDefaultLibFileName(options));
|
|
const defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : getDirectoryPath(getDefaultLibraryFileName());
|
|
const programDiagnostics = createDiagnosticCollection();
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const supportedExtensions = getSupportedExtensions(options);
|
|
const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
|
|
const hasEmitBlockingDiagnostics = /* @__PURE__ */ new Map();
|
|
let _compilerOptionsObjectLiteralSyntax;
|
|
let moduleResolutionCache;
|
|
let typeReferenceDirectiveResolutionCache;
|
|
let actualResolveModuleNamesWorker;
|
|
const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
|
|
if (host.resolveModuleNames) {
|
|
actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => {
|
|
var _a3;
|
|
return host.resolveModuleNames(
|
|
moduleNames.map((literal) => literal.text),
|
|
containingFileName,
|
|
(_a3 = resolutionInfo == null ? void 0 : resolutionInfo.reusedNames) == null ? void 0 : _a3.map((literal) => literal.text),
|
|
redirectedReference,
|
|
options,
|
|
containingFile,
|
|
resolutionInfo
|
|
).map((resolved) => {
|
|
if (!resolved || resolved.extension !== void 0) {
|
|
return resolved;
|
|
}
|
|
const withExtension = clone(resolved);
|
|
withExtension.extension = extensionFromPath(resolved.resolvedFileName);
|
|
return withExtension;
|
|
});
|
|
};
|
|
moduleResolutionCache = (_b = host.getModuleResolutionCache) == null ? void 0 : _b.call(host);
|
|
} else {
|
|
moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
|
|
const loader = (moduleName, resolverMode, containingFileName, redirectedReference) => resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
|
|
actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo, loader);
|
|
}
|
|
let actualResolveTypeReferenceDirectiveNamesWorker;
|
|
if (host.resolveTypeReferenceDirectives) {
|
|
actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) => host.resolveTypeReferenceDirectives(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode, resolutionInfo);
|
|
} else {
|
|
typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
|
|
const loader = (typesRef, containingFile, redirectedReference, resolutionMode) => resolveTypeReferenceDirective(
|
|
typesRef,
|
|
containingFile,
|
|
options,
|
|
host,
|
|
redirectedReference,
|
|
typeReferenceDirectiveResolutionCache,
|
|
resolutionMode
|
|
).resolvedTypeReferenceDirective;
|
|
actualResolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
|
|
}
|
|
const packageIdToSourceFile = /* @__PURE__ */ new Map();
|
|
let sourceFileToPackageName = /* @__PURE__ */ new Map();
|
|
let redirectTargetsMap = createMultiMap();
|
|
let usesUriStyleNodeCoreModules = false;
|
|
const filesByName = /* @__PURE__ */ new Map();
|
|
let missingFilePaths;
|
|
const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? /* @__PURE__ */ new Map() : void 0;
|
|
let resolvedProjectReferences;
|
|
let projectReferenceRedirects;
|
|
let mapFromFileToProjectReferenceRedirects;
|
|
let mapFromToProjectReferenceRedirectSource;
|
|
const useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _c.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
|
|
const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
|
|
compilerHost: host,
|
|
getSymlinkCache,
|
|
useSourceOfProjectReferenceRedirect,
|
|
toPath: toPath3,
|
|
getResolvedProjectReferences,
|
|
getSourceOfProjectReferenceRedirect,
|
|
forEachResolvedProjectReference: forEachResolvedProjectReference2
|
|
});
|
|
const readFile = host.readFile.bind(host);
|
|
(_d = tracing) == null ? void 0 : _d.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
|
|
const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
|
|
(_e = tracing) == null ? void 0 : _e.pop();
|
|
let structureIsReused;
|
|
(_f = tracing) == null ? void 0 : _f.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
|
|
structureIsReused = tryReuseStructureFromOldProgram();
|
|
(_g = tracing) == null ? void 0 : _g.pop();
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
processingDefaultLibFiles = [];
|
|
processingOtherFiles = [];
|
|
if (projectReferences) {
|
|
if (!resolvedProjectReferences) {
|
|
resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
if (rootNames.length) {
|
|
resolvedProjectReferences == null ? void 0 : resolvedProjectReferences.forEach((parsedRef, index) => {
|
|
if (!parsedRef)
|
|
return;
|
|
const out = outFile(parsedRef.commandLine.options);
|
|
if (useSourceOfProjectReferenceRedirect) {
|
|
if (out || getEmitModuleKind(parsedRef.commandLine.options) === 0 /* None */) {
|
|
for (const fileName of parsedRef.commandLine.fileNames) {
|
|
processProjectReferenceFile(fileName, { kind: 1 /* SourceFromProjectReference */, index });
|
|
}
|
|
}
|
|
} else {
|
|
if (out) {
|
|
processProjectReferenceFile(changeExtension(out, ".d.ts"), { kind: 2 /* OutputFromProjectReference */, index });
|
|
} else if (getEmitModuleKind(parsedRef.commandLine.options) === 0 /* None */) {
|
|
const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(parsedRef.commandLine, !host.useCaseSensitiveFileNames()));
|
|
for (const fileName of parsedRef.commandLine.fileNames) {
|
|
if (!isDeclarationFileName(fileName) && !fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
processProjectReferenceFile(getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory3), { kind: 2 /* OutputFromProjectReference */, index });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
(_h = tracing) == null ? void 0 : _h.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
|
|
forEach(rootNames, (name, index) => processRootFile(name, false, false, { kind: 0 /* RootFile */, index }));
|
|
(_i = tracing) == null ? void 0 : _i.pop();
|
|
const typeReferences = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
|
|
if (typeReferences.length) {
|
|
(_j = tracing) == null ? void 0 : _j.push(tracing.Phase.Program, "processTypeReferences", { count: typeReferences.length });
|
|
const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
|
|
const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);
|
|
const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeReferences, containingFilename);
|
|
for (let i = 0; i < typeReferences.length; i++) {
|
|
processTypeReferenceDirective(typeReferences[i], void 0, resolutions[i], { kind: 8 /* AutomaticTypeDirectiveFile */, typeReference: typeReferences[i], packageId: (_k = resolutions[i]) == null ? void 0 : _k.packageId });
|
|
}
|
|
(_l = tracing) == null ? void 0 : _l.pop();
|
|
}
|
|
if (rootNames.length && !skipDefaultLib) {
|
|
const defaultLibraryFileName = getDefaultLibraryFileName();
|
|
if (!options.lib && defaultLibraryFileName) {
|
|
processRootFile(defaultLibraryFileName, true, false, { kind: 6 /* LibFile */ });
|
|
} else {
|
|
forEach(options.lib, (libFileName, index) => {
|
|
processRootFile(pathForLibFile(libFileName), true, false, { kind: 6 /* LibFile */, index });
|
|
});
|
|
}
|
|
}
|
|
missingFilePaths = arrayFrom(mapDefinedIterator(filesByName.entries(), ([path, file]) => file === void 0 ? path : void 0));
|
|
files = stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles);
|
|
processingDefaultLibFiles = void 0;
|
|
processingOtherFiles = void 0;
|
|
}
|
|
Debug.assert(!!missingFilePaths);
|
|
if (oldProgram && host.onReleaseOldSourceFile) {
|
|
const oldSourceFiles = oldProgram.getSourceFiles();
|
|
for (const oldSourceFile of oldSourceFiles) {
|
|
const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
|
|
if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
|
|
host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
|
|
}
|
|
}
|
|
if (!host.getParsedCommandLine) {
|
|
oldProgram.forEachResolvedProjectReference((resolvedProjectReference) => {
|
|
if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
|
|
host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), false);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (oldProgram && host.onReleaseParsedCommandLine) {
|
|
forEachProjectReference(
|
|
oldProgram.getProjectReferences(),
|
|
oldProgram.getResolvedProjectReferences(),
|
|
(oldResolvedRef, parent, index) => {
|
|
const oldReference = (parent == null ? void 0 : parent.commandLine.projectReferences[index]) || oldProgram.getProjectReferences()[index];
|
|
const oldRefPath = resolveProjectReferencePath(oldReference);
|
|
if (!(projectReferenceRedirects == null ? void 0 : projectReferenceRedirects.has(toPath3(oldRefPath)))) {
|
|
host.onReleaseParsedCommandLine(oldRefPath, oldResolvedRef, oldProgram.getCompilerOptions());
|
|
}
|
|
}
|
|
);
|
|
}
|
|
typeReferenceDirectiveResolutionCache = void 0;
|
|
oldProgram = void 0;
|
|
const program = {
|
|
getRootFileNames: () => rootNames,
|
|
getSourceFile,
|
|
getSourceFileByPath,
|
|
getSourceFiles: () => files,
|
|
getMissingFilePaths: () => missingFilePaths,
|
|
getModuleResolutionCache: () => moduleResolutionCache,
|
|
getFilesByNameMap: () => filesByName,
|
|
getCompilerOptions: () => options,
|
|
getSyntacticDiagnostics,
|
|
getOptionsDiagnostics,
|
|
getGlobalDiagnostics,
|
|
getSemanticDiagnostics,
|
|
getCachedSemanticDiagnostics,
|
|
getSuggestionDiagnostics,
|
|
getDeclarationDiagnostics: getDeclarationDiagnostics2,
|
|
getBindAndCheckDiagnostics,
|
|
getProgramDiagnostics,
|
|
getTypeChecker,
|
|
getClassifiableNames,
|
|
getCommonSourceDirectory: getCommonSourceDirectory2,
|
|
emit,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
getNodeCount: () => getTypeChecker().getNodeCount(),
|
|
getIdentifierCount: () => getTypeChecker().getIdentifierCount(),
|
|
getSymbolCount: () => getTypeChecker().getSymbolCount(),
|
|
getTypeCount: () => getTypeChecker().getTypeCount(),
|
|
getInstantiationCount: () => getTypeChecker().getInstantiationCount(),
|
|
getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
|
|
getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
|
|
getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
|
|
isSourceFileFromExternalLibrary,
|
|
isSourceFileDefaultLibrary,
|
|
getSourceFileFromReference,
|
|
getLibFileFromReference,
|
|
sourceFileToPackageName,
|
|
redirectTargetsMap,
|
|
usesUriStyleNodeCoreModules,
|
|
isEmittedFile,
|
|
getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
|
|
getResolvedModuleWithFailedLookupLocationsFromCache,
|
|
getProjectReferences,
|
|
getResolvedProjectReferences,
|
|
getProjectReferenceRedirect,
|
|
getResolvedProjectReferenceToRedirect,
|
|
getResolvedProjectReferenceByPath,
|
|
forEachResolvedProjectReference: forEachResolvedProjectReference2,
|
|
isSourceOfProjectReferenceRedirect,
|
|
emitBuildInfo,
|
|
fileExists,
|
|
readFile,
|
|
directoryExists,
|
|
getSymlinkCache,
|
|
realpath: (_m = host.realpath) == null ? void 0 : _m.bind(host),
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getFileIncludeReasons: () => fileReasons,
|
|
structureIsReused,
|
|
writeFile: writeFile2
|
|
};
|
|
onProgramCreateComplete();
|
|
fileProcessingDiagnostics == null ? void 0 : fileProcessingDiagnostics.forEach((diagnostic) => {
|
|
switch (diagnostic.kind) {
|
|
case 1 /* FilePreprocessingFileExplainingDiagnostic */:
|
|
return programDiagnostics.add(createDiagnosticExplainingFile(diagnostic.file && getSourceFileByPath(diagnostic.file), diagnostic.fileProcessingReason, diagnostic.diagnostic, diagnostic.args || emptyArray));
|
|
case 0 /* FilePreprocessingReferencedDiagnostic */:
|
|
const { file, pos, end } = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason);
|
|
return programDiagnostics.add(createFileDiagnostic(file, Debug.checkDefined(pos), Debug.checkDefined(end) - pos, diagnostic.diagnostic, ...diagnostic.args || emptyArray));
|
|
default:
|
|
Debug.assertNever(diagnostic);
|
|
}
|
|
});
|
|
verifyCompilerOptions();
|
|
mark("afterProgram");
|
|
measure("Program", "beforeProgram", "afterProgram");
|
|
(_n = tracing) == null ? void 0 : _n.pop();
|
|
return program;
|
|
function addResolutionDiagnostics(list) {
|
|
if (!list)
|
|
return;
|
|
for (const elem of list) {
|
|
programDiagnostics.add(elem);
|
|
}
|
|
}
|
|
function pullDiagnosticsFromCache(names, containingFile) {
|
|
var _a3;
|
|
if (!moduleResolutionCache)
|
|
return;
|
|
const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
|
|
const containingDir = getDirectoryPath(containingFileName);
|
|
const redirectedReference = getRedirectReferenceForResolution(containingFile);
|
|
for (const n of names) {
|
|
const mode = getResolutionMode(n, containingFile);
|
|
const name = getResolutionName(n);
|
|
if (isExternalModuleNameRelative(name))
|
|
continue;
|
|
const diags = (_a3 = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) == null ? void 0 : _a3.resolutionDiagnostics;
|
|
addResolutionDiagnostics(diags);
|
|
}
|
|
}
|
|
function resolveModuleNamesWorker(moduleNames, containingFile, resolutionInfo) {
|
|
var _a3, _b2;
|
|
if (!moduleNames.length)
|
|
return emptyArray;
|
|
const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
|
|
const redirectedReference = getRedirectReferenceForResolution(containingFile);
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
|
|
mark("beforeResolveModule");
|
|
const result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo);
|
|
mark("afterResolveModule");
|
|
measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
pullDiagnosticsFromCache(moduleNames, containingFile);
|
|
return result;
|
|
}
|
|
function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, resolutionInfo) {
|
|
var _a3, _b2;
|
|
if (!typeDirectiveNames.length)
|
|
return [];
|
|
const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
|
|
const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : void 0;
|
|
const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : void 0;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
|
|
mark("beforeResolveTypeReference");
|
|
const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode, resolutionInfo);
|
|
mark("afterResolveTypeReference");
|
|
measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function getRedirectReferenceForResolution(file) {
|
|
const redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
|
|
if (redirect || !isDeclarationFileName(file.originalFileName))
|
|
return redirect;
|
|
const resultFromDts = getRedirectReferenceForResolutionFromSourceOfProject(file.path);
|
|
if (resultFromDts)
|
|
return resultFromDts;
|
|
if (!host.realpath || !options.preserveSymlinks || !stringContains(file.originalFileName, nodeModulesPathPart))
|
|
return void 0;
|
|
const realDeclarationPath = toPath3(host.realpath(file.originalFileName));
|
|
return realDeclarationPath === file.path ? void 0 : getRedirectReferenceForResolutionFromSourceOfProject(realDeclarationPath);
|
|
}
|
|
function getRedirectReferenceForResolutionFromSourceOfProject(filePath) {
|
|
const source = getSourceOfProjectReferenceRedirect(filePath);
|
|
if (isString(source))
|
|
return getResolvedProjectReferenceToRedirect(source);
|
|
if (!source)
|
|
return void 0;
|
|
return forEachResolvedProjectReference2((resolvedRef) => {
|
|
const out = outFile(resolvedRef.commandLine.options);
|
|
if (!out)
|
|
return void 0;
|
|
return toPath3(out) === filePath ? resolvedRef : void 0;
|
|
});
|
|
}
|
|
function compareDefaultLibFiles(a, b) {
|
|
return compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b));
|
|
}
|
|
function getDefaultLibFilePriority(a) {
|
|
if (containsPath(defaultLibraryPath, a.fileName, false)) {
|
|
const basename = getBaseFileName(a.fileName);
|
|
if (basename === "lib.d.ts" || basename === "lib.es6.d.ts")
|
|
return 0;
|
|
const name = removeSuffix(removePrefix(basename, "lib."), ".d.ts");
|
|
const index = libs.indexOf(name);
|
|
if (index !== -1)
|
|
return index + 1;
|
|
}
|
|
return libs.length + 2;
|
|
}
|
|
function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
|
|
return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
|
|
}
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function getCommonSourceDirectory2() {
|
|
if (commonSourceDirectory === void 0) {
|
|
const emittedFiles = filter(files, (file) => sourceFileMayBeEmitted(file, program));
|
|
commonSourceDirectory = getCommonSourceDirectory(
|
|
options,
|
|
() => mapDefined(emittedFiles, (file) => file.isDeclarationFile ? void 0 : file.fileName),
|
|
currentDirectory,
|
|
getCanonicalFileName,
|
|
(commonSourceDirectory2) => checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory2)
|
|
);
|
|
}
|
|
return commonSourceDirectory;
|
|
}
|
|
function getClassifiableNames() {
|
|
var _a3;
|
|
if (!classifiableNames) {
|
|
getTypeChecker();
|
|
classifiableNames = /* @__PURE__ */ new Set();
|
|
for (const sourceFile of files) {
|
|
(_a3 = sourceFile.classifiableNames) == null ? void 0 : _a3.forEach((value) => classifiableNames.add(value));
|
|
}
|
|
}
|
|
return classifiableNames;
|
|
}
|
|
function resolveModuleNamesReusingOldState(moduleNames, file) {
|
|
if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
|
|
return resolveModuleNamesWorker(moduleNames, file, void 0);
|
|
}
|
|
const oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
|
|
if (oldSourceFile !== file && file.resolvedModules) {
|
|
const result2 = [];
|
|
for (const moduleName of moduleNames) {
|
|
const resolvedModule = file.resolvedModules.get(moduleName.text, getModeForUsageLocation(file, moduleName));
|
|
result2.push(resolvedModule);
|
|
}
|
|
return result2;
|
|
}
|
|
let unknownModuleNames;
|
|
let result;
|
|
let reusedNames;
|
|
const predictedToResolveToAmbientModuleMarker = {};
|
|
for (let i = 0; i < moduleNames.length; i++) {
|
|
const moduleName = moduleNames[i];
|
|
if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) {
|
|
const mode = getModeForUsageLocation(file, moduleName);
|
|
const oldResolvedModule = getResolvedModule(oldSourceFile, moduleName.text, mode);
|
|
if (oldResolvedModule) {
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(
|
|
host,
|
|
oldResolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
|
|
moduleName.text,
|
|
getNormalizedAbsolutePath(file.originalFileName, currentDirectory),
|
|
oldResolvedModule.resolvedFileName,
|
|
oldResolvedModule.packageId && packageIdToString(oldResolvedModule.packageId)
|
|
);
|
|
}
|
|
(result != null ? result : result = new Array(moduleNames.length))[i] = oldResolvedModule;
|
|
(reusedNames != null ? reusedNames : reusedNames = []).push(moduleName);
|
|
continue;
|
|
}
|
|
}
|
|
let resolvesToAmbientModuleInNonModifiedFile = false;
|
|
if (contains(file.ambientModuleNames, moduleName.text)) {
|
|
resolvesToAmbientModuleInNonModifiedFile = true;
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
|
|
}
|
|
} else {
|
|
resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName);
|
|
}
|
|
if (resolvesToAmbientModuleInNonModifiedFile) {
|
|
(result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
|
|
} else {
|
|
(unknownModuleNames != null ? unknownModuleNames : unknownModuleNames = []).push(moduleName);
|
|
}
|
|
}
|
|
const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, { names: unknownModuleNames, reusedNames }) : emptyArray;
|
|
if (!result) {
|
|
Debug.assert(resolutions.length === moduleNames.length);
|
|
return resolutions;
|
|
}
|
|
let j = 0;
|
|
for (let i = 0; i < result.length; i++) {
|
|
if (result[i]) {
|
|
if (result[i] === predictedToResolveToAmbientModuleMarker) {
|
|
result[i] = void 0;
|
|
}
|
|
} else {
|
|
result[i] = resolutions[j];
|
|
j++;
|
|
}
|
|
}
|
|
Debug.assert(j === resolutions.length);
|
|
return result;
|
|
function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) {
|
|
const resolutionToFile = getResolvedModule(oldSourceFile, moduleName.text, getModeForUsageLocation(file, moduleName));
|
|
const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
|
|
if (resolutionToFile && resolvedFile) {
|
|
return false;
|
|
}
|
|
const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
|
|
if (!unmodifiedFile) {
|
|
return false;
|
|
}
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
|
|
if (structureIsReused === 0 /* Not */) {
|
|
return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, void 0);
|
|
}
|
|
const oldSourceFile = !isString(containingFile) ? oldProgram && oldProgram.getSourceFile(containingFile.fileName) : void 0;
|
|
if (!isString(containingFile)) {
|
|
if (oldSourceFile !== containingFile && containingFile.resolvedTypeReferenceDirectiveNames) {
|
|
const result2 = [];
|
|
for (const typeDirectiveName of typeDirectiveNames) {
|
|
const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getResolutionName(typeDirectiveName), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat);
|
|
result2.push(resolvedTypeReferenceDirective);
|
|
}
|
|
return result2;
|
|
}
|
|
}
|
|
let unknownTypeReferenceDirectiveNames;
|
|
let result;
|
|
let reusedNames;
|
|
const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
|
|
const canReuseResolutions = !isString(containingFile) ? containingFile === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path) : !hasInvalidatedResolutions(toPath3(containingFile));
|
|
for (let i = 0; i < typeDirectiveNames.length; i++) {
|
|
const entry = typeDirectiveNames[i];
|
|
if (canReuseResolutions) {
|
|
const typeDirectiveName = getResolutionName(entry);
|
|
const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
|
|
const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
|
|
if (oldResolvedTypeReferenceDirective) {
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(
|
|
host,
|
|
oldResolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
|
|
typeDirectiveName,
|
|
!isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
|
|
oldResolvedTypeReferenceDirective.resolvedFileName,
|
|
oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
|
|
);
|
|
}
|
|
(result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolvedTypeReferenceDirective;
|
|
(reusedNames != null ? reusedNames : reusedNames = []).push(entry);
|
|
continue;
|
|
}
|
|
}
|
|
(unknownTypeReferenceDirectiveNames != null ? unknownTypeReferenceDirectiveNames : unknownTypeReferenceDirectiveNames = []).push(entry);
|
|
}
|
|
if (!unknownTypeReferenceDirectiveNames)
|
|
return result || emptyArray;
|
|
const resolutions = resolveTypeReferenceDirectiveNamesWorker(
|
|
unknownTypeReferenceDirectiveNames,
|
|
containingFile,
|
|
{ names: unknownTypeReferenceDirectiveNames, reusedNames }
|
|
);
|
|
if (!result) {
|
|
Debug.assert(resolutions.length === typeDirectiveNames.length);
|
|
return resolutions;
|
|
}
|
|
let j = 0;
|
|
for (let i = 0; i < result.length; i++) {
|
|
if (!result[i]) {
|
|
result[i] = resolutions[j];
|
|
j++;
|
|
}
|
|
}
|
|
Debug.assert(j === resolutions.length);
|
|
return result;
|
|
}
|
|
function canReuseProjectReferences() {
|
|
return !forEachProjectReference(
|
|
oldProgram.getProjectReferences(),
|
|
oldProgram.getResolvedProjectReferences(),
|
|
(oldResolvedRef, parent, index) => {
|
|
const newRef = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
|
|
const newResolvedRef = parseProjectReferenceConfigFile(newRef);
|
|
if (oldResolvedRef) {
|
|
return !newResolvedRef || newResolvedRef.sourceFile !== oldResolvedRef.sourceFile || !arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newResolvedRef.commandLine.fileNames);
|
|
} else {
|
|
return newResolvedRef !== void 0;
|
|
}
|
|
},
|
|
(oldProjectReferences, parent) => {
|
|
const newReferences = parent ? getResolvedProjectReferenceByPath(parent.sourceFile.path).commandLine.projectReferences : projectReferences;
|
|
return !arrayIsEqualTo(oldProjectReferences, newReferences, projectReferenceIsEqualTo);
|
|
}
|
|
);
|
|
}
|
|
function tryReuseStructureFromOldProgram() {
|
|
var _a3, _b2;
|
|
if (!oldProgram) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldOptions = oldProgram.getCompilerOptions();
|
|
if (changesAffectModuleResolution(oldOptions, options)) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldRootNames = oldProgram.getRootFileNames();
|
|
if (!arrayIsEqualTo(oldRootNames, rootNames)) {
|
|
return 0 /* Not */;
|
|
}
|
|
if (!canReuseProjectReferences()) {
|
|
return 0 /* Not */;
|
|
}
|
|
if (projectReferences) {
|
|
resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
const newSourceFiles = [];
|
|
const modifiedSourceFiles = [];
|
|
structureIsReused = 2 /* Completely */;
|
|
if (oldProgram.getMissingFilePaths().some((missingFilePath) => host.fileExists(missingFilePath))) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldSourceFiles = oldProgram.getSourceFiles();
|
|
let SeenPackageName;
|
|
((SeenPackageName2) => {
|
|
SeenPackageName2[SeenPackageName2["Exists"] = 0] = "Exists";
|
|
SeenPackageName2[SeenPackageName2["Modified"] = 1] = "Modified";
|
|
})(SeenPackageName || (SeenPackageName = {}));
|
|
const seenPackageNames = /* @__PURE__ */ new Map();
|
|
for (const oldSourceFile of oldSourceFiles) {
|
|
const sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options);
|
|
let newSourceFile = host.getSourceFileByPath ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, void 0, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat) : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, void 0, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat);
|
|
if (!newSourceFile) {
|
|
return 0 /* Not */;
|
|
}
|
|
newSourceFile.packageJsonLocations = ((_a3 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a3.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
newSourceFile.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`");
|
|
let fileChanged;
|
|
if (oldSourceFile.redirectInfo) {
|
|
if (newSourceFile !== oldSourceFile.redirectInfo.unredirected) {
|
|
return 0 /* Not */;
|
|
}
|
|
fileChanged = false;
|
|
newSourceFile = oldSourceFile;
|
|
} else if (oldProgram.redirectTargetsMap.has(oldSourceFile.path)) {
|
|
if (newSourceFile !== oldSourceFile) {
|
|
return 0 /* Not */;
|
|
}
|
|
fileChanged = false;
|
|
} else {
|
|
fileChanged = newSourceFile !== oldSourceFile;
|
|
}
|
|
newSourceFile.path = oldSourceFile.path;
|
|
newSourceFile.originalFileName = oldSourceFile.originalFileName;
|
|
newSourceFile.resolvedPath = oldSourceFile.resolvedPath;
|
|
newSourceFile.fileName = oldSourceFile.fileName;
|
|
const packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path);
|
|
if (packageName !== void 0) {
|
|
const prevKind = seenPackageNames.get(packageName);
|
|
const newKind = fileChanged ? 1 /* Modified */ : 0 /* Exists */;
|
|
if (prevKind !== void 0 && newKind === 1 /* Modified */ || prevKind === 1 /* Modified */) {
|
|
return 0 /* Not */;
|
|
}
|
|
seenPackageNames.set(packageName, newKind);
|
|
}
|
|
if (fileChanged) {
|
|
if (oldSourceFile.impliedNodeFormat !== newSourceFile.impliedNodeFormat) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else {
|
|
collectExternalModuleReferences(newSourceFile);
|
|
if (!arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
}
|
|
}
|
|
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
|
|
} else if (hasInvalidatedResolutions(oldSourceFile.path)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
|
|
}
|
|
newSourceFiles.push(newSourceFile);
|
|
}
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
return structureIsReused;
|
|
}
|
|
const modifiedFiles = modifiedSourceFiles.map((f) => f.oldFile);
|
|
for (const oldFile of oldSourceFiles) {
|
|
if (!contains(modifiedFiles, oldFile)) {
|
|
for (const moduleName of oldFile.ambientModuleNames) {
|
|
ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
|
|
}
|
|
}
|
|
}
|
|
for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
|
|
const moduleNames = getModuleNames(newSourceFile);
|
|
const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
|
|
const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
|
|
if (resolutionsChanged) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
|
|
} else {
|
|
newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
|
|
}
|
|
const typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
|
|
const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
|
|
const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);
|
|
if (typeReferenceResolutionsChanged) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
|
|
} else {
|
|
newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
|
|
}
|
|
}
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
return structureIsReused;
|
|
}
|
|
if (changesAffectingProgramStructure(oldOptions, options) || ((_b2 = host.hasChangedAutomaticTypeDirectiveNames) == null ? void 0 : _b2.call(host))) {
|
|
return 1 /* SafeModules */;
|
|
}
|
|
missingFilePaths = oldProgram.getMissingFilePaths();
|
|
Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
|
|
for (const newSourceFile of newSourceFiles) {
|
|
filesByName.set(newSourceFile.path, newSourceFile);
|
|
}
|
|
const oldFilesByNameMap = oldProgram.getFilesByNameMap();
|
|
oldFilesByNameMap.forEach((oldFile, path) => {
|
|
if (!oldFile) {
|
|
filesByName.set(path, oldFile);
|
|
return;
|
|
}
|
|
if (oldFile.path === path) {
|
|
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 /* Completely */;
|
|
}
|
|
function getEmitHost(writeFileCallback) {
|
|
return {
|
|
getPrependNodes,
|
|
getCanonicalFileName,
|
|
getCommonSourceDirectory: program.getCommonSourceDirectory,
|
|
getCompilerOptions: program.getCompilerOptions,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
getNewLine: () => host.getNewLine(),
|
|
getSourceFile: program.getSourceFile,
|
|
getSourceFileByPath: program.getSourceFileByPath,
|
|
getSourceFiles: program.getSourceFiles,
|
|
getLibFileFromReference: program.getLibFileFromReference,
|
|
isSourceFileFromExternalLibrary,
|
|
getResolvedProjectReferenceToRedirect,
|
|
getProjectReferenceRedirect,
|
|
isSourceOfProjectReferenceRedirect,
|
|
getSymlinkCache,
|
|
writeFile: writeFileCallback || writeFile2,
|
|
isEmitBlocked,
|
|
readFile: (f) => host.readFile(f),
|
|
fileExists: (f) => {
|
|
const path = toPath3(f);
|
|
if (getSourceFileByPath(path))
|
|
return true;
|
|
if (contains(missingFilePaths, path))
|
|
return false;
|
|
return host.fileExists(f);
|
|
},
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getBuildInfo: (bundle) => {
|
|
var _a3;
|
|
return (_a3 = program.getBuildInfo) == null ? void 0 : _a3.call(program, bundle);
|
|
},
|
|
getSourceFileFromReference: (file, ref) => program.getSourceFileFromReference(file, ref),
|
|
redirectTargetsMap,
|
|
getFileIncludeReasons: program.getFileIncludeReasons,
|
|
createHash: maybeBind(host, host.createHash)
|
|
};
|
|
}
|
|
function writeFile2(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
|
|
host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
}
|
|
function emitBuildInfo(writeFileCallback) {
|
|
var _a3, _b2;
|
|
Debug.assert(!outFile(options));
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Emit, "emitBuildInfo", {}, true);
|
|
mark("beforeEmit");
|
|
const emitResult = emitFiles(
|
|
notImplementedResolver,
|
|
getEmitHost(writeFileCallback),
|
|
void 0,
|
|
noTransformers,
|
|
false,
|
|
true
|
|
);
|
|
mark("afterEmit");
|
|
measure("Emit", "beforeEmit", "afterEmit");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return emitResult;
|
|
}
|
|
function getResolvedProjectReferences() {
|
|
return resolvedProjectReferences;
|
|
}
|
|
function getProjectReferences() {
|
|
return projectReferences;
|
|
}
|
|
function getPrependNodes() {
|
|
return createPrependNodes(
|
|
projectReferences,
|
|
(_ref, index) => {
|
|
var _a3;
|
|
return (_a3 = resolvedProjectReferences[index]) == null ? void 0 : _a3.commandLine;
|
|
},
|
|
(fileName) => {
|
|
const path = toPath3(fileName);
|
|
const sourceFile = getSourceFileByPath(path);
|
|
return sourceFile ? sourceFile.text : filesByName.has(path) ? void 0 : host.readFile(path);
|
|
},
|
|
host
|
|
);
|
|
}
|
|
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;
|
|
}
|
|
const equalityComparer = host.useCaseSensitiveFileNames() ? equateStringsCaseSensitive : equateStringsCaseInsensitive;
|
|
if (!options.lib) {
|
|
return equalityComparer(file.fileName, getDefaultLibraryFileName());
|
|
} else {
|
|
return some(options.lib, (libFileName) => equalityComparer(file.fileName, pathForLibFile(libFileName)));
|
|
}
|
|
}
|
|
function getTypeChecker() {
|
|
return typeChecker || (typeChecker = createTypeChecker(program));
|
|
}
|
|
function emit(sourceFile, writeFileCallback, cancellationToken, emitOnly, transformers, forceDtsEmit) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Emit, "emit", { path: sourceFile == null ? void 0 : sourceFile.path }, true);
|
|
const result = runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnly, transformers, forceDtsEmit));
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function isEmitBlocked(emitFileName) {
|
|
return hasEmitBlockingDiagnostics.has(toPath3(emitFileName));
|
|
}
|
|
function emitWorker(program2, sourceFile, writeFileCallback, cancellationToken, emitOnly, customTransformers, forceDtsEmit) {
|
|
if (!forceDtsEmit) {
|
|
const result = handleNoEmitOptions(program2, sourceFile, writeFileCallback, cancellationToken);
|
|
if (result)
|
|
return result;
|
|
}
|
|
const emitResolver = getTypeChecker().getEmitResolver(outFile(options) ? void 0 : sourceFile, cancellationToken);
|
|
mark("beforeEmit");
|
|
const emitResult = emitFiles(
|
|
emitResolver,
|
|
getEmitHost(writeFileCallback),
|
|
sourceFile,
|
|
getTransformers(options, customTransformers, emitOnly),
|
|
emitOnly,
|
|
false,
|
|
forceDtsEmit
|
|
);
|
|
mark("afterEmit");
|
|
measure("Emit", "beforeEmit", "afterEmit");
|
|
return emitResult;
|
|
}
|
|
function getSourceFile(fileName) {
|
|
return getSourceFileByPath(toPath3(fileName));
|
|
}
|
|
function getSourceFileByPath(path) {
|
|
return filesByName.get(path) || void 0;
|
|
}
|
|
function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
|
|
if (sourceFile) {
|
|
return getDiagnostics(sourceFile, cancellationToken);
|
|
}
|
|
return sortAndDeduplicateDiagnostics(flatMap(program.getSourceFiles(), (sourceFile2) => {
|
|
if (cancellationToken) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
return getDiagnostics(sourceFile2, cancellationToken);
|
|
}));
|
|
}
|
|
function getSyntacticDiagnostics(sourceFile, cancellationToken) {
|
|
return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken);
|
|
}
|
|
function getSemanticDiagnostics(sourceFile, cancellationToken) {
|
|
return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);
|
|
}
|
|
function getCachedSemanticDiagnostics(sourceFile) {
|
|
var _a3;
|
|
return sourceFile ? (_a3 = cachedBindAndCheckDiagnosticsForFile.perFile) == null ? void 0 : _a3.get(sourceFile.path) : cachedBindAndCheckDiagnosticsForFile.allDiagnostics;
|
|
}
|
|
function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
|
|
return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken);
|
|
}
|
|
function getProgramDiagnostics(sourceFile) {
|
|
var _a3;
|
|
if (skipTypeChecking(sourceFile, options, program)) {
|
|
return emptyArray;
|
|
}
|
|
const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
|
|
if (!((_a3 = sourceFile.commentDirectives) == null ? void 0 : _a3.length)) {
|
|
return programDiagnosticsInFile;
|
|
}
|
|
return getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, programDiagnosticsInFile).diagnostics;
|
|
}
|
|
function getDeclarationDiagnostics2(sourceFile, cancellationToken) {
|
|
const options2 = program.getCompilerOptions();
|
|
if (!sourceFile || outFile(options2)) {
|
|
return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
|
|
} else {
|
|
return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken);
|
|
}
|
|
}
|
|
function getSyntacticDiagnosticsForFile(sourceFile) {
|
|
if (isSourceFileJS(sourceFile)) {
|
|
if (!sourceFile.additionalSyntacticDiagnostics) {
|
|
sourceFile.additionalSyntacticDiagnostics = getJSSyntacticDiagnosticsForFile(sourceFile);
|
|
}
|
|
return concatenate(sourceFile.additionalSyntacticDiagnostics, sourceFile.parseDiagnostics);
|
|
}
|
|
return sourceFile.parseDiagnostics;
|
|
}
|
|
function runWithCancellationToken(func) {
|
|
try {
|
|
return func();
|
|
} catch (e) {
|
|
if (e instanceof OperationCanceledException) {
|
|
typeChecker = void 0;
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return concatenate(
|
|
filterSemanticDiagnostics(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), options),
|
|
getProgramDiagnostics(sourceFile)
|
|
);
|
|
}
|
|
function getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedBindAndCheckDiagnosticsForFile, getBindAndCheckDiagnosticsForFileNoCache);
|
|
}
|
|
function getBindAndCheckDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
if (skipTypeChecking(sourceFile, options, program)) {
|
|
return emptyArray;
|
|
}
|
|
const typeChecker2 = getTypeChecker();
|
|
Debug.assert(!!sourceFile.bindDiagnostics);
|
|
const isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
|
|
const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
|
|
const isPlainJs = isPlainJsFile(sourceFile, options.checkJs);
|
|
const isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
|
|
const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 /* TS */ || sourceFile.scriptKind === 4 /* TSX */ || sourceFile.scriptKind === 5 /* External */ || isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* Deferred */);
|
|
let bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
|
|
let checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker2.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
|
|
if (isPlainJs) {
|
|
bindDiagnostics = filter(bindDiagnostics, (d) => plainJSErrors.has(d.code));
|
|
checkDiagnostics = filter(checkDiagnostics, (d) => plainJSErrors.has(d.code));
|
|
}
|
|
return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : void 0);
|
|
});
|
|
}
|
|
function getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, ...allDiagnostics) {
|
|
var _a3;
|
|
const flatDiagnostics = flatten(allDiagnostics);
|
|
if (!includeBindAndCheckDiagnostics || !((_a3 = sourceFile.commentDirectives) == null ? void 0 : _a3.length)) {
|
|
return flatDiagnostics;
|
|
}
|
|
const { diagnostics, directives } = getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, flatDiagnostics);
|
|
for (const errorExpectation of directives.getUnusedExpectations()) {
|
|
diagnostics.push(createDiagnosticForRange(sourceFile, errorExpectation.range, Diagnostics.Unused_ts_expect_error_directive));
|
|
}
|
|
return diagnostics;
|
|
}
|
|
function getDiagnosticsWithPrecedingDirectives(sourceFile, commentDirectives, flatDiagnostics) {
|
|
const directives = createCommentDirectivesMap(sourceFile, commentDirectives);
|
|
const diagnostics = flatDiagnostics.filter((diagnostic) => markPrecedingCommentDirectiveLine(diagnostic, directives) === -1);
|
|
return { diagnostics, directives };
|
|
}
|
|
function getSuggestionDiagnostics(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
return getTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
|
|
});
|
|
}
|
|
function markPrecedingCommentDirectiveLine(diagnostic, directives) {
|
|
const { file, start } = diagnostic;
|
|
if (!file) {
|
|
return -1;
|
|
}
|
|
const lineStarts = getLineStarts(file);
|
|
let line = computeLineAndCharacterOfPosition(lineStarts, start).line - 1;
|
|
while (line >= 0) {
|
|
if (directives.markUsed(line)) {
|
|
return line;
|
|
}
|
|
const 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(() => {
|
|
const diagnostics = [];
|
|
walk(sourceFile, sourceFile);
|
|
forEachChildRecursively(sourceFile, walk, walkArray);
|
|
return diagnostics;
|
|
function walk(node, parent) {
|
|
switch (parent.kind) {
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (parent.questionToken === node) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
|
|
return "skip";
|
|
}
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
case 257 /* VariableDeclaration */:
|
|
if (parent.type === node) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(parent, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "export type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, isImportSpecifier(node) ? "import...type" : "export...type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.import_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 274 /* ExportAssignment */:
|
|
if (node.isExportEquals) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.export_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 294 /* HeritageClause */:
|
|
const heritageClause = node;
|
|
if (heritageClause.token === 117 /* ImplementsKeyword */) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.implements_clauses_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 261 /* InterfaceDeclaration */:
|
|
const interfaceKeyword = tokenToString(118 /* InterfaceKeyword */);
|
|
Debug.assertIsDefined(interfaceKeyword);
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, interfaceKeyword));
|
|
return "skip";
|
|
case 264 /* ModuleDeclaration */:
|
|
const moduleKeyword = node.flags & 16 /* Namespace */ ? tokenToString(143 /* NamespaceKeyword */) : tokenToString(142 /* ModuleKeyword */);
|
|
Debug.assertIsDefined(moduleKeyword);
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, moduleKeyword));
|
|
return "skip";
|
|
case 262 /* TypeAliasDeclaration */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 263 /* EnumDeclaration */:
|
|
const enumKeyword = Debug.checkDefined(tokenToString(92 /* EnumKeyword */));
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, enumKeyword));
|
|
return "skip";
|
|
case 232 /* NonNullExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 231 /* AsExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node.type, Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 235 /* SatisfiesExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node.type, Diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 213 /* TypeAssertionExpression */:
|
|
Debug.fail();
|
|
}
|
|
}
|
|
function walkArray(nodes, parent) {
|
|
if (canHaveModifiers(parent) && parent.modifiers === nodes && some(nodes, isDecorator) && !options.experimentalDecorators) {
|
|
diagnostics.push(createDiagnosticForNode2(parent, 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 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
if (nodes === parent.typeParameters) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
case 240 /* VariableStatement */:
|
|
if (nodes === parent.modifiers) {
|
|
checkModifiers(parent.modifiers, parent.kind === 240 /* VariableStatement */);
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (nodes === parent.modifiers) {
|
|
for (const modifier of nodes) {
|
|
if (isModifier(modifier) && modifier.kind !== 124 /* StaticKeyword */ && modifier.kind !== 127 /* AccessorKeyword */) {
|
|
diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
|
|
}
|
|
}
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 166 /* Parameter */:
|
|
if (nodes === parent.modifiers && some(nodes, isModifier)) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
if (nodes === parent.typeArguments) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function checkModifiers(modifiers, isConstValid) {
|
|
for (const modifier of modifiers) {
|
|
switch (modifier.kind) {
|
|
case 85 /* ConstKeyword */:
|
|
if (isConstValid) {
|
|
continue;
|
|
}
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
}
|
|
}
|
|
}
|
|
function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
|
|
const start = nodes.pos;
|
|
return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2);
|
|
}
|
|
function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
|
|
return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
|
|
}
|
|
});
|
|
}
|
|
function getDeclarationDiagnosticsWorker(sourceFile, cancellationToken) {
|
|
return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedDeclarationDiagnosticsForFile, getDeclarationDiagnosticsForFileNoCache);
|
|
}
|
|
function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
const resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
|
|
return getDeclarationDiagnostics(getEmitHost(noop), resolver, sourceFile) || emptyArray;
|
|
});
|
|
}
|
|
function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics) {
|
|
var _a3;
|
|
const cachedResult = sourceFile ? (_a3 = cache.perFile) == null ? void 0 : _a3.get(sourceFile.path) : cache.allDiagnostics;
|
|
if (cachedResult) {
|
|
return cachedResult;
|
|
}
|
|
const result = getDiagnostics(sourceFile, cancellationToken);
|
|
if (sourceFile) {
|
|
(cache.perFile || (cache.perFile = /* @__PURE__ */ new Map())).set(sourceFile.path, result);
|
|
} else {
|
|
cache.allDiagnostics = result;
|
|
}
|
|
return result;
|
|
}
|
|
function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return sourceFile.isDeclarationFile ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
|
|
}
|
|
function getOptionsDiagnostics() {
|
|
return sortAndDeduplicateDiagnostics(concatenate(
|
|
programDiagnostics.getGlobalDiagnostics(),
|
|
getOptionsDiagnosticsOfConfigFile()
|
|
));
|
|
}
|
|
function getOptionsDiagnosticsOfConfigFile() {
|
|
if (!options.configFile)
|
|
return emptyArray;
|
|
let diagnostics = programDiagnostics.getDiagnostics(options.configFile.fileName);
|
|
forEachResolvedProjectReference2((resolvedRef) => {
|
|
diagnostics = concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName));
|
|
});
|
|
return diagnostics;
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
return rootNames.length ? sortAndDeduplicateDiagnostics(getTypeChecker().getGlobalDiagnostics().slice()) : emptyArray;
|
|
}
|
|
function getConfigFileParsingDiagnostics2() {
|
|
return configFileParsingDiagnostics || emptyArray;
|
|
}
|
|
function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason) {
|
|
processSourceFile(normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, void 0, reason);
|
|
}
|
|
function fileReferenceIsEqualTo(a, b) {
|
|
return a.fileName === b.fileName;
|
|
}
|
|
function moduleNameIsEqualTo(a, b) {
|
|
return a.kind === 79 /* Identifier */ ? b.kind === 79 /* Identifier */ && a.escapedText === b.escapedText : b.kind === 10 /* StringLiteral */ && a.text === b.text;
|
|
}
|
|
function createSyntheticImport(text, file) {
|
|
const externalHelpersModuleReference = factory.createStringLiteral(text);
|
|
const importDecl = factory.createImportDeclaration(void 0, void 0, externalHelpersModuleReference, void 0);
|
|
addEmitFlags(importDecl, 134217728 /* NeverApplyImportHelper */);
|
|
setParent(externalHelpersModuleReference, importDecl);
|
|
setParent(importDecl, file);
|
|
externalHelpersModuleReference.flags &= ~8 /* Synthesized */;
|
|
importDecl.flags &= ~8 /* Synthesized */;
|
|
return externalHelpersModuleReference;
|
|
}
|
|
function collectExternalModuleReferences(file) {
|
|
if (file.imports) {
|
|
return;
|
|
}
|
|
const isJavaScriptFile = isSourceFileJS(file);
|
|
const isExternalModuleFile = isExternalModule(file);
|
|
let imports;
|
|
let moduleAugmentations;
|
|
let ambientModules;
|
|
if ((options.isolatedModules || isExternalModuleFile) && !file.isDeclarationFile) {
|
|
if (options.importHelpers) {
|
|
imports = [createSyntheticImport(externalHelpersModuleNameText, file)];
|
|
}
|
|
const jsxImport = getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
|
|
if (jsxImport) {
|
|
(imports || (imports = [])).push(createSyntheticImport(jsxImport, file));
|
|
}
|
|
}
|
|
for (const node of file.statements) {
|
|
collectModuleReferences(node, false);
|
|
}
|
|
if (file.flags & 2097152 /* PossiblyContainsDynamicImport */ || isJavaScriptFile) {
|
|
collectDynamicImportOrRequireCalls(file);
|
|
}
|
|
file.imports = imports || emptyArray;
|
|
file.moduleAugmentations = moduleAugmentations || emptyArray;
|
|
file.ambientModuleNames = ambientModules || emptyArray;
|
|
return;
|
|
function collectModuleReferences(node, inAmbientModule) {
|
|
if (isAnyImportOrReExport(node)) {
|
|
const moduleNameExpr = getExternalModuleName(node);
|
|
if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text && (!inAmbientModule || !isExternalModuleNameRelative(moduleNameExpr.text))) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, moduleNameExpr);
|
|
if (!usesUriStyleNodeCoreModules && currentNodeModulesDepth === 0 && !file.isDeclarationFile) {
|
|
usesUriStyleNodeCoreModules = startsWith(moduleNameExpr.text, "node:");
|
|
}
|
|
}
|
|
} else if (isModuleDeclaration(node)) {
|
|
if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 2 /* Ambient */) || file.isDeclarationFile)) {
|
|
node.name.parent = node;
|
|
const nameText = getTextOfIdentifierOrLiteral(node.name);
|
|
if (isExternalModuleFile || inAmbientModule && !isExternalModuleNameRelative(nameText)) {
|
|
(moduleAugmentations || (moduleAugmentations = [])).push(node.name);
|
|
} else if (!inAmbientModule) {
|
|
if (file.isDeclarationFile) {
|
|
(ambientModules || (ambientModules = [])).push(nameText);
|
|
}
|
|
const body = node.body;
|
|
if (body) {
|
|
for (const statement of body.statements) {
|
|
collectModuleReferences(statement, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function collectDynamicImportOrRequireCalls(file2) {
|
|
const r = /import|require/g;
|
|
while (r.exec(file2.text) !== null) {
|
|
const node = getNodeAtPosition(file2, r.lastIndex);
|
|
if (isJavaScriptFile && isRequireCall(node, true)) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.arguments[0]);
|
|
} else if (isImportCall(node) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.arguments[0]);
|
|
} else if (isLiteralImportTypeNode(node)) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.argument.literal);
|
|
}
|
|
}
|
|
}
|
|
function getNodeAtPosition(sourceFile, position) {
|
|
let current = sourceFile;
|
|
const getContainingChild = (child) => {
|
|
if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) {
|
|
return child;
|
|
}
|
|
};
|
|
while (true) {
|
|
const child = isJavaScriptFile && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
|
|
if (!child) {
|
|
return current;
|
|
}
|
|
current = child;
|
|
}
|
|
}
|
|
}
|
|
function getLibFileFromReference(ref) {
|
|
const libName = toFileNameLowerCase(ref.fileName);
|
|
const libFileName = libMap.get(libName);
|
|
if (libFileName) {
|
|
return getSourceFile(pathForLibFile(libFileName));
|
|
}
|
|
}
|
|
function getSourceFileFromReference(referencingFile, ref) {
|
|
return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile);
|
|
}
|
|
function getSourceFileFromReferenceWorker(fileName, getSourceFile2, fail, reason) {
|
|
if (hasExtension(fileName)) {
|
|
const canonicalFileName = host.getCanonicalFileName(fileName);
|
|
if (!options.allowNonTsExtensions && !forEach(flatten(supportedExtensionsWithJsonIfResolveJsonModule), (extension) => fileExtensionIs(canonicalFileName, extension))) {
|
|
if (fail) {
|
|
if (hasJSFileExtension(canonicalFileName)) {
|
|
fail(Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName);
|
|
} else {
|
|
fail(Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
const sourceFile = getSourceFile2(fileName);
|
|
if (fail) {
|
|
if (!sourceFile) {
|
|
const redirect = getProjectReferenceRedirect(fileName);
|
|
if (redirect) {
|
|
fail(Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, fileName);
|
|
} else {
|
|
fail(Diagnostics.File_0_not_found, fileName);
|
|
}
|
|
} else if (isReferencedFile(reason) && canonicalFileName === host.getCanonicalFileName(getSourceFileByPath(reason.file).fileName)) {
|
|
fail(Diagnostics.A_file_cannot_have_a_reference_to_itself);
|
|
}
|
|
}
|
|
return sourceFile;
|
|
} else {
|
|
const sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile2(fileName);
|
|
if (sourceFileNoExtension)
|
|
return sourceFileNoExtension;
|
|
if (fail && options.allowNonTsExtensions) {
|
|
fail(Diagnostics.File_0_not_found, fileName);
|
|
return void 0;
|
|
}
|
|
const sourceFileWithAddedExtension = forEach(supportedExtensions[0], (extension) => getSourceFile2(fileName + extension));
|
|
if (fail && !sourceFileWithAddedExtension)
|
|
fail(Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
|
|
return sourceFileWithAddedExtension;
|
|
}
|
|
}
|
|
function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, reason) {
|
|
getSourceFileFromReferenceWorker(
|
|
fileName,
|
|
(fileName2) => findSourceFile(fileName2, isDefaultLib, ignoreNoDefaultLib, reason, packageId),
|
|
(diagnostic, ...args) => addFilePreprocessingFileExplainingDiagnostic(void 0, reason, diagnostic, args),
|
|
reason
|
|
);
|
|
}
|
|
function processProjectReferenceFile(fileName, reason) {
|
|
return processSourceFile(fileName, false, false, void 0, reason);
|
|
}
|
|
function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason) {
|
|
const hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && some(fileReasons.get(existingFile.path), isReferencedFile);
|
|
if (hasExistingReasonToReportErrorOn) {
|
|
addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [existingFile.fileName, fileName]);
|
|
} else {
|
|
addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, 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 _a3;
|
|
const redirect = Object.create(redirectTarget);
|
|
redirect.fileName = fileName;
|
|
redirect.path = path;
|
|
redirect.resolvedPath = resolvedPath;
|
|
redirect.originalFileName = originalFileName;
|
|
redirect.redirectInfo = { redirectTarget, unredirected };
|
|
redirect.packageJsonLocations = ((_a3 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a3.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
|
|
Object.defineProperties(redirect, {
|
|
id: {
|
|
get() {
|
|
return this.redirectInfo.redirectTarget.id;
|
|
},
|
|
set(value) {
|
|
this.redirectInfo.redirectTarget.id = value;
|
|
}
|
|
},
|
|
symbol: {
|
|
get() {
|
|
return this.redirectInfo.redirectTarget.symbol;
|
|
},
|
|
set(value) {
|
|
this.redirectInfo.redirectTarget.symbol = value;
|
|
}
|
|
}
|
|
});
|
|
return redirect;
|
|
}
|
|
function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "findSourceFile", {
|
|
fileName,
|
|
isDefaultLib: isDefaultLib || void 0,
|
|
fileIncludeKind: FileIncludeKind[reason.kind]
|
|
});
|
|
const result = findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function getCreateSourceFileOptions(fileName, moduleResolutionCache2, host2, options2) {
|
|
const result = getImpliedNodeFormatForFileWorker(getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache2 == null ? void 0 : moduleResolutionCache2.getPackageJsonInfoCache(), host2, options2);
|
|
const languageVersion = getEmitScriptTarget(options2);
|
|
const setExternalModuleIndicator2 = getSetExternalModuleIndicator(options2);
|
|
return typeof result === "object" ? { ...result, languageVersion, setExternalModuleIndicator: setExternalModuleIndicator2 } : { languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator2 };
|
|
}
|
|
function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
|
|
var _a3, _b2;
|
|
const path = toPath3(fileName);
|
|
if (useSourceOfProjectReferenceRedirect) {
|
|
let source = getSourceOfProjectReferenceRedirect(path);
|
|
if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && stringContains(fileName, nodeModulesPathPart)) {
|
|
const realPath2 = toPath3(host.realpath(fileName));
|
|
if (realPath2 !== path)
|
|
source = getSourceOfProjectReferenceRedirect(realPath2);
|
|
}
|
|
if (source) {
|
|
const file2 = isString(source) ? findSourceFile(source, isDefaultLib, ignoreNoDefaultLib, reason, packageId) : void 0;
|
|
if (file2)
|
|
addFileToFilesByName(file2, path, void 0);
|
|
return file2;
|
|
}
|
|
}
|
|
const originalFileName = fileName;
|
|
if (filesByName.has(path)) {
|
|
const file2 = filesByName.get(path);
|
|
addFileIncludeReason(file2 || void 0, reason);
|
|
if (file2 && options.forceConsistentCasingInFileNames) {
|
|
const checkedName = file2.fileName;
|
|
const isRedirect = toPath3(checkedName) !== toPath3(fileName);
|
|
if (isRedirect) {
|
|
fileName = getProjectReferenceRedirect(fileName) || fileName;
|
|
}
|
|
const checkedAbsolutePath = getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory);
|
|
const inputAbsolutePath = getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory);
|
|
if (checkedAbsolutePath !== inputAbsolutePath) {
|
|
reportFileNamesDifferOnlyInCasingError(fileName, file2, reason);
|
|
}
|
|
}
|
|
if (file2 && sourceFilesFoundSearchingNodeModules.get(file2.path) && currentNodeModulesDepth === 0) {
|
|
sourceFilesFoundSearchingNodeModules.set(file2.path, false);
|
|
if (!options.noResolve) {
|
|
processReferencedFiles(file2, isDefaultLib);
|
|
processTypeReferenceDirectives(file2);
|
|
}
|
|
if (!options.noLib) {
|
|
processLibReferenceDirectives(file2);
|
|
}
|
|
modulesWithElidedImports.set(file2.path, false);
|
|
processImportedModules(file2);
|
|
} else if (file2 && modulesWithElidedImports.get(file2.path)) {
|
|
if (currentNodeModulesDepth < maxNodeModuleJsDepth) {
|
|
modulesWithElidedImports.set(file2.path, false);
|
|
processImportedModules(file2);
|
|
}
|
|
}
|
|
return file2 || void 0;
|
|
}
|
|
let redirectedPath;
|
|
if (isReferencedFile(reason) && !useSourceOfProjectReferenceRedirect) {
|
|
const redirectProject = getProjectReferenceRedirectProject(fileName);
|
|
if (redirectProject) {
|
|
if (outFile(redirectProject.commandLine.options)) {
|
|
return void 0;
|
|
}
|
|
const redirect = getProjectReferenceOutputName(redirectProject, fileName);
|
|
fileName = redirect;
|
|
redirectedPath = toPath3(redirect);
|
|
}
|
|
}
|
|
const sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options);
|
|
const file = host.getSourceFile(
|
|
fileName,
|
|
sourceFileOptions,
|
|
(hostErrorMessage) => addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]),
|
|
shouldCreateNewSourceFile || ((_a3 = oldProgram == null ? void 0 : oldProgram.getSourceFileByPath(toPath3(fileName))) == null ? void 0 : _a3.impliedNodeFormat) !== sourceFileOptions.impliedNodeFormat
|
|
);
|
|
if (packageId) {
|
|
const packageIdKey = packageIdToString(packageId);
|
|
const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
|
|
if (fileFromPackageId) {
|
|
const dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath3(fileName), originalFileName, sourceFileOptions);
|
|
redirectTargetsMap.add(fileFromPackageId.path, fileName);
|
|
addFileToFilesByName(dupFile, path, redirectedPath);
|
|
addFileIncludeReason(dupFile, reason);
|
|
sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
|
|
processingOtherFiles.push(dupFile);
|
|
return dupFile;
|
|
} else if (file) {
|
|
packageIdToSourceFile.set(packageIdKey, file);
|
|
sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
|
|
}
|
|
}
|
|
addFileToFilesByName(file, path, redirectedPath);
|
|
if (file) {
|
|
sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
|
|
file.fileName = fileName;
|
|
file.path = path;
|
|
file.resolvedPath = toPath3(fileName);
|
|
file.originalFileName = originalFileName;
|
|
file.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
file.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
addFileIncludeReason(file, reason);
|
|
if (host.useCaseSensitiveFileNames()) {
|
|
const pathLowerCase = toFileNameLowerCase(path);
|
|
const 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);
|
|
}
|
|
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) {
|
|
const referencedProject = getProjectReferenceRedirectProject(fileName);
|
|
return referencedProject && getProjectReferenceOutputName(referencedProject, fileName);
|
|
}
|
|
function getProjectReferenceRedirectProject(fileName) {
|
|
if (!resolvedProjectReferences || !resolvedProjectReferences.length || isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
return void 0;
|
|
}
|
|
return getResolvedProjectReferenceToRedirect(fileName);
|
|
}
|
|
function getProjectReferenceOutputName(referencedProject, fileName) {
|
|
const out = outFile(referencedProject.commandLine.options);
|
|
return out ? changeExtension(out, ".d.ts" /* Dts */) : getOutputDeclarationFileName(fileName, referencedProject.commandLine, !host.useCaseSensitiveFileNames());
|
|
}
|
|
function getResolvedProjectReferenceToRedirect(fileName) {
|
|
if (mapFromFileToProjectReferenceRedirects === void 0) {
|
|
mapFromFileToProjectReferenceRedirects = /* @__PURE__ */ new Map();
|
|
forEachResolvedProjectReference2((referencedProject) => {
|
|
if (toPath3(options.configFilePath) !== referencedProject.sourceFile.path) {
|
|
referencedProject.commandLine.fileNames.forEach((f) => mapFromFileToProjectReferenceRedirects.set(toPath3(f), referencedProject.sourceFile.path));
|
|
}
|
|
});
|
|
}
|
|
const referencedProjectPath = mapFromFileToProjectReferenceRedirects.get(toPath3(fileName));
|
|
return referencedProjectPath && getResolvedProjectReferenceByPath(referencedProjectPath);
|
|
}
|
|
function forEachResolvedProjectReference2(cb) {
|
|
return forEachResolvedProjectReference(resolvedProjectReferences, cb);
|
|
}
|
|
function getSourceOfProjectReferenceRedirect(path) {
|
|
if (!isDeclarationFileName(path))
|
|
return void 0;
|
|
if (mapFromToProjectReferenceRedirectSource === void 0) {
|
|
mapFromToProjectReferenceRedirectSource = /* @__PURE__ */ new Map();
|
|
forEachResolvedProjectReference2((resolvedRef) => {
|
|
const out = outFile(resolvedRef.commandLine.options);
|
|
if (out) {
|
|
const outputDts = changeExtension(out, ".d.ts" /* Dts */);
|
|
mapFromToProjectReferenceRedirectSource.set(toPath3(outputDts), true);
|
|
} else {
|
|
const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
|
|
forEach(resolvedRef.commandLine.fileNames, (fileName) => {
|
|
if (!isDeclarationFileName(fileName) && !fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
const outputDts = getOutputDeclarationFileName(fileName, resolvedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory3);
|
|
mapFromToProjectReferenceRedirectSource.set(toPath3(outputDts), fileName);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return mapFromToProjectReferenceRedirectSource.get(path);
|
|
}
|
|
function isSourceOfProjectReferenceRedirect(fileName) {
|
|
return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName);
|
|
}
|
|
function getResolvedProjectReferenceByPath(projectReferencePath) {
|
|
if (!projectReferenceRedirects) {
|
|
return void 0;
|
|
}
|
|
return projectReferenceRedirects.get(projectReferencePath) || void 0;
|
|
}
|
|
function processReferencedFiles(file, isDefaultLib) {
|
|
forEach(file.referencedFiles, (ref, index) => {
|
|
processSourceFile(
|
|
resolveTripleslashReference(ref.fileName, file.fileName),
|
|
isDefaultLib,
|
|
false,
|
|
void 0,
|
|
{ kind: 4 /* ReferenceFile */, file: file.path, index }
|
|
);
|
|
});
|
|
}
|
|
function processTypeReferenceDirectives(file) {
|
|
const typeDirectives = file.typeReferenceDirectives;
|
|
if (!typeDirectives) {
|
|
return;
|
|
}
|
|
const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
|
|
for (let index = 0; index < typeDirectives.length; index++) {
|
|
const ref = file.typeReferenceDirectives[index];
|
|
const resolvedTypeReferenceDirective = resolutions[index];
|
|
const fileName = toFileNameLowerCase(ref.fileName);
|
|
setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
|
|
const mode = ref.resolutionMode || file.impliedNodeFormat;
|
|
if (mode && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
|
|
programDiagnostics.add(createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
|
|
}
|
|
processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
|
|
}
|
|
}
|
|
function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
|
|
processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
}
|
|
function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
|
|
const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
|
|
if (previousResolution && previousResolution.primary) {
|
|
return;
|
|
}
|
|
let saveResolution = true;
|
|
if (resolvedTypeReferenceDirective) {
|
|
if (resolvedTypeReferenceDirective.isExternalLibraryImport)
|
|
currentNodeModulesDepth++;
|
|
if (resolvedTypeReferenceDirective.primary) {
|
|
processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, reason);
|
|
} else {
|
|
if (previousResolution) {
|
|
if (resolvedTypeReferenceDirective.resolvedFileName !== previousResolution.resolvedFileName) {
|
|
const otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName);
|
|
const existingFile = getSourceFile(previousResolution.resolvedFileName);
|
|
if (otherFileText !== existingFile.text) {
|
|
addFilePreprocessingFileExplainingDiagnostic(
|
|
existingFile,
|
|
reason,
|
|
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]
|
|
);
|
|
}
|
|
}
|
|
saveResolution = false;
|
|
} else {
|
|
processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, reason);
|
|
}
|
|
}
|
|
if (resolvedTypeReferenceDirective.isExternalLibraryImport)
|
|
currentNodeModulesDepth--;
|
|
} else {
|
|
addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
|
|
}
|
|
if (saveResolution) {
|
|
resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
|
|
}
|
|
}
|
|
function pathForLibFile(libFileName) {
|
|
const components = libFileName.split(".");
|
|
let path = components[1];
|
|
let i = 2;
|
|
while (components[i] && components[i] !== "d") {
|
|
path += (i === 2 ? "/" : "-") + components[i];
|
|
i++;
|
|
}
|
|
const resolveFrom = combinePaths(currentDirectory, `__lib_node_modules_lookup_${libFileName}__.ts`);
|
|
const localOverrideModuleResult = resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: 2 /* NodeJs */ }, host, moduleResolutionCache);
|
|
if (localOverrideModuleResult == null ? void 0 : localOverrideModuleResult.resolvedModule) {
|
|
return localOverrideModuleResult.resolvedModule.resolvedFileName;
|
|
}
|
|
return combinePaths(defaultLibraryPath, libFileName);
|
|
}
|
|
function processLibReferenceDirectives(file) {
|
|
forEach(file.libReferenceDirectives, (libReference, index) => {
|
|
const libName = toFileNameLowerCase(libReference.fileName);
|
|
const libFileName = libMap.get(libName);
|
|
if (libFileName) {
|
|
processRootFile(pathForLibFile(libFileName), true, true, { kind: 7 /* LibReferenceDirective */, file: file.path, index });
|
|
} else {
|
|
const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
|
|
const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
|
|
const diagnostic = suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0;
|
|
(fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
|
|
kind: 0 /* FilePreprocessingReferencedDiagnostic */,
|
|
reason: { kind: 7 /* LibReferenceDirective */, file: file.path, index },
|
|
diagnostic,
|
|
args: [libName, suggestion]
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function getCanonicalFileName(fileName) {
|
|
return host.getCanonicalFileName(fileName);
|
|
}
|
|
function processImportedModules(file) {
|
|
var _a3;
|
|
collectExternalModuleReferences(file);
|
|
if (file.imports.length || file.moduleAugmentations.length) {
|
|
const moduleNames = getModuleNames(file);
|
|
const resolutions = resolveModuleNamesReusingOldState(moduleNames, file);
|
|
Debug.assert(resolutions.length === moduleNames.length);
|
|
const optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a3 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a3.commandLine.options : void 0) || options;
|
|
for (let index = 0; index < moduleNames.length; index++) {
|
|
const resolution = resolutions[index];
|
|
setResolvedModule(file, moduleNames[index].text, resolution, getModeForUsageLocation(file, moduleNames[index]));
|
|
if (!resolution) {
|
|
continue;
|
|
}
|
|
const isFromNodeModulesSearch = resolution.isExternalLibraryImport;
|
|
const isJsFile = !resolutionExtensionIsTSOrJson(resolution.extension);
|
|
const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
|
|
const resolvedFileName = resolution.resolvedFileName;
|
|
if (isFromNodeModulesSearch) {
|
|
currentNodeModulesDepth++;
|
|
}
|
|
const elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModuleJsDepth;
|
|
const shouldAddFile = resolvedFileName && !getResolutionDiagnostic(optionsForFile, resolution) && !optionsForFile.noResolve && index < file.imports.length && !elideImport && !(isJsFile && !getAllowJSCompilerOption(optionsForFile)) && (isInJSFile(file.imports[index]) || !(file.imports[index].flags & 8388608 /* JSDoc */));
|
|
if (elideImport) {
|
|
modulesWithElidedImports.set(file.path, true);
|
|
} else if (shouldAddFile) {
|
|
findSourceFile(
|
|
resolvedFileName,
|
|
false,
|
|
false,
|
|
{ kind: 3 /* Import */, file: file.path, index },
|
|
resolution.packageId
|
|
);
|
|
}
|
|
if (isFromNodeModulesSearch) {
|
|
currentNodeModulesDepth--;
|
|
}
|
|
}
|
|
} else {
|
|
file.resolvedModules = void 0;
|
|
}
|
|
}
|
|
function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) {
|
|
let allFilesBelongToPath = true;
|
|
const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
|
|
for (const sourceFile of sourceFiles) {
|
|
if (!sourceFile.isDeclarationFile) {
|
|
const absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
|
|
if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
|
|
addProgramDiagnosticExplainingFile(
|
|
sourceFile,
|
|
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 = /* @__PURE__ */ new Map();
|
|
}
|
|
const refPath = resolveProjectReferencePath(ref);
|
|
const sourceFilePath = toPath3(refPath);
|
|
const fromCache = projectReferenceRedirects.get(sourceFilePath);
|
|
if (fromCache !== void 0) {
|
|
return fromCache || void 0;
|
|
}
|
|
let commandLine;
|
|
let sourceFile;
|
|
if (host.getParsedCommandLine) {
|
|
commandLine = host.getParsedCommandLine(refPath);
|
|
if (!commandLine) {
|
|
addFileToFilesByName(void 0, sourceFilePath, void 0);
|
|
projectReferenceRedirects.set(sourceFilePath, false);
|
|
return void 0;
|
|
}
|
|
sourceFile = Debug.checkDefined(commandLine.options.configFile);
|
|
Debug.assert(!sourceFile.path || sourceFile.path === sourceFilePath);
|
|
addFileToFilesByName(sourceFile, sourceFilePath, void 0);
|
|
} else {
|
|
const basePath = getNormalizedAbsolutePath(getDirectoryPath(refPath), host.getCurrentDirectory());
|
|
sourceFile = host.getSourceFile(refPath, 100 /* JSON */);
|
|
addFileToFilesByName(sourceFile, sourceFilePath, void 0);
|
|
if (sourceFile === void 0) {
|
|
projectReferenceRedirects.set(sourceFilePath, false);
|
|
return void 0;
|
|
}
|
|
commandLine = parseJsonSourceFileConfigFileContent(sourceFile, configParsingHost, basePath, void 0, refPath);
|
|
}
|
|
sourceFile.fileName = refPath;
|
|
sourceFile.path = sourceFilePath;
|
|
sourceFile.resolvedPath = sourceFilePath;
|
|
sourceFile.originalFileName = refPath;
|
|
const resolvedRef = { commandLine, sourceFile };
|
|
projectReferenceRedirects.set(sourceFilePath, resolvedRef);
|
|
if (commandLine.projectReferences) {
|
|
resolvedRef.references = commandLine.projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
return resolvedRef;
|
|
}
|
|
function verifyCompilerOptions() {
|
|
if (options.strictPropertyInitialization && !getStrictOptionValue(options, "strictNullChecks")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
|
|
}
|
|
if (options.exactOptionalPropertyTypes && !getStrictOptionValue(options, "strictNullChecks")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks");
|
|
}
|
|
if (options.isolatedModules) {
|
|
if (options.out) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules");
|
|
}
|
|
if (options.outFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules");
|
|
}
|
|
}
|
|
if (options.inlineSourceMap) {
|
|
if (options.sourceMap) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap");
|
|
}
|
|
if (options.mapRoot) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap");
|
|
}
|
|
}
|
|
if (options.composite) {
|
|
if (options.declaration === false) {
|
|
createDiagnosticForOptionName(Diagnostics.Composite_projects_may_not_disable_declaration_emit, "declaration");
|
|
}
|
|
if (options.incremental === false) {
|
|
createDiagnosticForOptionName(Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration");
|
|
}
|
|
}
|
|
const outputFile = outFile(options);
|
|
if (options.tsBuildInfoFile) {
|
|
if (!isIncrementalCompilation(options)) {
|
|
createDiagnosticForOptionName(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(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
|
|
}
|
|
verifyProjectReferences();
|
|
if (options.composite) {
|
|
const rootPaths = new Set(rootNames.map(toPath3));
|
|
for (const file of files) {
|
|
if (sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) {
|
|
addProgramDiagnosticExplainingFile(
|
|
file,
|
|
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 (const key in options.paths) {
|
|
if (!hasProperty(options.paths, key)) {
|
|
continue;
|
|
}
|
|
if (!hasZeroOrOneAsteriskCharacter(key)) {
|
|
createDiagnosticForOptionPaths(true, key, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, key);
|
|
}
|
|
if (isArray(options.paths[key])) {
|
|
const len = options.paths[key].length;
|
|
if (len === 0) {
|
|
createDiagnosticForOptionPaths(false, key, Diagnostics.Substitutions_for_pattern_0_shouldn_t_be_an_empty_array, key);
|
|
}
|
|
for (let i = 0; i < len; i++) {
|
|
const subst = options.paths[key][i];
|
|
const typeOfSubst = typeof subst;
|
|
if (typeOfSubst === "string") {
|
|
if (!hasZeroOrOneAsteriskCharacter(subst)) {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, subst, key);
|
|
}
|
|
if (!options.baseUrl && !pathIsRelative(subst) && !pathIsAbsolute(subst)) {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash);
|
|
}
|
|
} else {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst);
|
|
}
|
|
}
|
|
} else {
|
|
createDiagnosticForOptionPaths(false, key, Diagnostics.Substitutions_for_pattern_0_should_be_an_array, key);
|
|
}
|
|
}
|
|
}
|
|
if (!options.sourceMap && !options.inlineSourceMap) {
|
|
if (options.inlineSources) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources");
|
|
}
|
|
if (options.sourceRoot) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot");
|
|
}
|
|
}
|
|
if (options.out && options.outFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile");
|
|
}
|
|
if (options.mapRoot && !(options.sourceMap || options.declarationMap)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "mapRoot", "sourceMap", "declarationMap");
|
|
}
|
|
if (options.declarationDir) {
|
|
if (!getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite");
|
|
}
|
|
if (outputFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile");
|
|
}
|
|
}
|
|
if (options.declarationMap && !getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationMap", "declaration", "composite");
|
|
}
|
|
if (options.lib && options.noLib) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib");
|
|
}
|
|
if (options.noImplicitUseStrict && getStrictOptionValue(options, "alwaysStrict")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict");
|
|
}
|
|
const languageVersion = getEmitScriptTarget(options);
|
|
const firstNonAmbientExternalModuleSourceFile = find(files, (f) => isExternalModule(f) && !f.isDeclarationFile);
|
|
if (options.isolatedModules) {
|
|
if (options.module === 0 /* None */ && languageVersion < 2 /* ES2015 */) {
|
|
createDiagnosticForOptionName(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(Diagnostics.Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled, "preserveConstEnums", "isolatedModules");
|
|
}
|
|
for (const file of files) {
|
|
if (!isExternalModule(file) && !isSourceFileJS(file) && !file.isDeclarationFile && file.scriptKind !== 6 /* JSON */) {
|
|
const span = getErrorSpanForNode(file, file);
|
|
programDiagnostics.add(createFileDiagnostic(
|
|
file,
|
|
span.start,
|
|
span.length,
|
|
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,
|
|
getBaseFileName(file.fileName)
|
|
));
|
|
}
|
|
}
|
|
} else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 /* ES2015 */ && options.module === 0 /* None */) {
|
|
const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
|
|
programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
|
|
}
|
|
if (outputFile && !options.emitDeclarationOnly) {
|
|
if (options.module && !(options.module === 2 /* AMD */ || options.module === 4 /* System */)) {
|
|
createDiagnosticForOptionName(Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module");
|
|
} else if (options.module === void 0 && firstNonAmbientExternalModuleSourceFile) {
|
|
const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
|
|
programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile"));
|
|
}
|
|
}
|
|
if (options.resolveJsonModule) {
|
|
if (getEmitModuleResolutionKind(options) !== 2 /* NodeJs */ && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");
|
|
} else if (!hasJsonModuleEmitEnabled(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext, "resolveJsonModule", "module");
|
|
}
|
|
}
|
|
if (options.outDir || options.rootDir || options.sourceRoot || options.mapRoot) {
|
|
const dir = getCommonSourceDirectory2();
|
|
if (options.outDir && dir === "" && files.some((file) => getRootLength(file.fileName) > 1)) {
|
|
createDiagnosticForOptionName(Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files, "outDir");
|
|
}
|
|
}
|
|
if (options.useDefineForClassFields && languageVersion === 0 /* ES3 */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields");
|
|
}
|
|
if (options.checkJs && !getAllowJSCompilerOption(options)) {
|
|
programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs"));
|
|
}
|
|
if (options.emitDeclarationOnly) {
|
|
if (!getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "emitDeclarationOnly", "declaration", "composite");
|
|
}
|
|
if (options.noEmit) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationOnly", "noEmit");
|
|
}
|
|
}
|
|
if (options.emitDecoratorMetadata && !options.experimentalDecorators) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators");
|
|
}
|
|
if (options.jsxFactory) {
|
|
if (options.reactNamespace) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory");
|
|
}
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFactory", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
if (!parseIsolatedEntityName(options.jsxFactory, languageVersion)) {
|
|
createOptionValueDiagnostic("jsxFactory", Diagnostics.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFactory);
|
|
}
|
|
} else if (options.reactNamespace && !isIdentifierText(options.reactNamespace, languageVersion)) {
|
|
createOptionValueDiagnostic("reactNamespace", Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace);
|
|
}
|
|
if (options.jsxFragmentFactory) {
|
|
if (!options.jsxFactory) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "jsxFragmentFactory", "jsxFactory");
|
|
}
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFragmentFactory", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
if (!parseIsolatedEntityName(options.jsxFragmentFactory, languageVersion)) {
|
|
createOptionValueDiagnostic("jsxFragmentFactory", Diagnostics.Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFragmentFactory);
|
|
}
|
|
}
|
|
if (options.reactNamespace) {
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "reactNamespace", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
}
|
|
if (options.jsxImportSource) {
|
|
if (options.jsx === 2 /* React */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxImportSource", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
}
|
|
if (options.preserveValueImports && getEmitModuleKind(options) < 5 /* ES2015 */) {
|
|
createOptionValueDiagnostic("importsNotUsedAsValues", Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later);
|
|
}
|
|
if (!options.noEmit && !options.suppressOutputPathCheck) {
|
|
const emitHost = getEmitHost();
|
|
const emitFilesSeen = /* @__PURE__ */ new Set();
|
|
forEachEmittedFile(emitHost, (emitFileNames) => {
|
|
if (!options.emitDeclarationOnly) {
|
|
verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
|
|
}
|
|
verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);
|
|
});
|
|
}
|
|
function verifyEmitFilePath(emitFileName, emitFilesSeen) {
|
|
if (emitFileName) {
|
|
const emitFilePath = toPath3(emitFileName);
|
|
if (filesByName.has(emitFilePath)) {
|
|
let chain;
|
|
if (!options.configFilePath) {
|
|
chain = chainDiagnosticMessages(void 0, 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 = chainDiagnosticMessages(chain, Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file, emitFileName);
|
|
blockEmittingOfFile(emitFileName, createCompilerDiagnosticFromMessageChain(chain));
|
|
}
|
|
const emitFileKey = !host.useCaseSensitiveFileNames() ? toFileNameLowerCase(emitFilePath) : emitFilePath;
|
|
if (emitFilesSeen.has(emitFileKey)) {
|
|
blockEmittingOfFile(emitFileName, createCompilerDiagnostic(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 _a3;
|
|
let fileIncludeReasons;
|
|
let relatedInfo;
|
|
let locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : void 0;
|
|
if (file)
|
|
(_a3 = fileReasons.get(file.path)) == null ? void 0 : _a3.forEach(processReason);
|
|
if (fileProcessingReason)
|
|
processReason(fileProcessingReason);
|
|
if (locationReason && (fileIncludeReasons == null ? void 0 : fileIncludeReasons.length) === 1)
|
|
fileIncludeReasons = void 0;
|
|
const location = locationReason && getReferencedFileLocation(getSourceFileByPath, locationReason);
|
|
const fileIncludeReasonDetails = fileIncludeReasons && chainDiagnosticMessages(fileIncludeReasons, Diagnostics.The_file_is_in_the_program_because_Colon);
|
|
const redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file);
|
|
const chain = chainDiagnosticMessages(redirectInfo ? fileIncludeReasonDetails ? [fileIncludeReasonDetails, ...redirectInfo] : redirectInfo : fileIncludeReasonDetails, diagnostic, ...args || emptyArray);
|
|
return location && isReferenceFileLocation(location) ? createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : createCompilerDiagnosticFromMessageChain(chain, relatedInfo);
|
|
function processReason(reason) {
|
|
(fileIncludeReasons || (fileIncludeReasons = [])).push(fileIncludeReasonToDiagnostics(program, reason));
|
|
if (!locationReason && isReferencedFile(reason)) {
|
|
locationReason = reason;
|
|
} else if (locationReason !== reason) {
|
|
relatedInfo = append(relatedInfo, fileIncludeReasonToRelatedInformation(reason));
|
|
}
|
|
if (reason === fileProcessingReason)
|
|
fileProcessingReason = void 0;
|
|
}
|
|
}
|
|
function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) {
|
|
(fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
|
|
kind: 1 /* FilePreprocessingFileExplainingDiagnostic */,
|
|
file: file && file.path,
|
|
fileProcessingReason,
|
|
diagnostic,
|
|
args
|
|
});
|
|
}
|
|
function addProgramDiagnosticExplainingFile(file, diagnostic, args) {
|
|
programDiagnostics.add(createDiagnosticExplainingFile(file, void 0, diagnostic, args));
|
|
}
|
|
function fileIncludeReasonToRelatedInformation(reason) {
|
|
if (isReferencedFile(reason)) {
|
|
const referenceLocation = getReferencedFileLocation(getSourceFileByPath, reason);
|
|
let message2;
|
|
switch (reason.kind) {
|
|
case 3 /* Import */:
|
|
message2 = Diagnostics.File_is_included_via_import_here;
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
message2 = Diagnostics.File_is_included_via_reference_here;
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
message2 = Diagnostics.File_is_included_via_type_library_reference_here;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
message2 = Diagnostics.File_is_included_via_library_reference_here;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return isReferenceFileLocation(referenceLocation) ? createFileDiagnostic(
|
|
referenceLocation.file,
|
|
referenceLocation.pos,
|
|
referenceLocation.end - referenceLocation.pos,
|
|
message2
|
|
) : void 0;
|
|
}
|
|
if (!options.configFile)
|
|
return void 0;
|
|
let configFileNode;
|
|
let message;
|
|
switch (reason.kind) {
|
|
case 0 /* RootFile */:
|
|
if (!options.configFile.configFileSpecs)
|
|
return void 0;
|
|
const fileName = getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory);
|
|
const matchedByFiles = getMatchedFileSpec(program, fileName);
|
|
if (matchedByFiles) {
|
|
configFileNode = getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles);
|
|
message = Diagnostics.File_is_matched_by_files_list_specified_here;
|
|
break;
|
|
}
|
|
const matchedByInclude = getMatchedIncludeSpec(program, fileName);
|
|
if (!matchedByInclude || !isString(matchedByInclude))
|
|
return void 0;
|
|
configFileNode = getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude);
|
|
message = Diagnostics.File_is_matched_by_include_pattern_specified_here;
|
|
break;
|
|
case 1 /* SourceFromProjectReference */:
|
|
case 2 /* OutputFromProjectReference */:
|
|
const referencedResolvedRef = Debug.checkDefined(resolvedProjectReferences == null ? void 0 : resolvedProjectReferences[reason.index]);
|
|
const referenceInfo = forEachProjectReference(
|
|
projectReferences,
|
|
resolvedProjectReferences,
|
|
(resolvedRef, parent, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent == null ? void 0 : parent.sourceFile) || options.configFile, index: index2 } : void 0
|
|
);
|
|
if (!referenceInfo)
|
|
return void 0;
|
|
const { sourceFile, index } = referenceInfo;
|
|
const referencesSyntax = firstDefined(
|
|
getTsConfigPropArray(sourceFile, "references"),
|
|
(property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
|
|
);
|
|
return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
|
|
sourceFile,
|
|
referencesSyntax.elements[index],
|
|
reason.kind === 2 /* OutputFromProjectReference */ ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here
|
|
) : void 0;
|
|
case 8 /* AutomaticTypeDirectiveFile */:
|
|
if (!options.types)
|
|
return void 0;
|
|
configFileNode = getOptionsSyntaxByArrayElementValue("types", reason.typeReference);
|
|
message = Diagnostics.File_is_entry_point_of_type_library_specified_here;
|
|
break;
|
|
case 6 /* LibFile */:
|
|
if (reason.index !== void 0) {
|
|
configFileNode = getOptionsSyntaxByArrayElementValue("lib", options.lib[reason.index]);
|
|
message = Diagnostics.File_is_library_specified_here;
|
|
break;
|
|
}
|
|
const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
|
|
configFileNode = target ? getOptionsSyntaxByValue("target", target) : void 0;
|
|
message = Diagnostics.File_is_default_library_for_target_specified_here;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return configFileNode && createDiagnosticForNodeInSourceFile(
|
|
options.configFile,
|
|
configFileNode,
|
|
message
|
|
);
|
|
}
|
|
function verifyProjectReferences() {
|
|
const buildInfoPath = !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : void 0;
|
|
forEachProjectReference(projectReferences, resolvedProjectReferences, (resolvedRef, parent, index) => {
|
|
const ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
|
|
const parentFile = parent && parent.sourceFile;
|
|
if (!resolvedRef) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.File_0_not_found, ref.path);
|
|
return;
|
|
}
|
|
const options2 = resolvedRef.commandLine.options;
|
|
if (!options2.composite || options2.noEmit) {
|
|
const inputs = parent ? parent.commandLine.fileNames : rootNames;
|
|
if (inputs.length) {
|
|
if (!options2.composite)
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
|
|
if (options2.noEmit)
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path);
|
|
}
|
|
}
|
|
if (ref.prepend) {
|
|
const out = outFile(options2);
|
|
if (out) {
|
|
if (!host.fileExists(out)) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path);
|
|
}
|
|
} else {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_prepend_project_0_because_it_does_not_have_outFile_set, ref.path);
|
|
}
|
|
}
|
|
if (!parent && buildInfoPath && buildInfoPath === getTsBuildInfoEmitOutputFilePath(options2)) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path);
|
|
hasEmitBlockingDiagnostics.set(toPath3(buildInfoPath), true);
|
|
}
|
|
});
|
|
}
|
|
function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) {
|
|
let needCompilerDiagnostic = true;
|
|
const pathsSyntax = getOptionPathsSyntax();
|
|
for (const pathProp of pathsSyntax) {
|
|
if (isObjectLiteralExpression(pathProp.initializer)) {
|
|
for (const keyProps of getPropertyAssignment(pathProp.initializer, key)) {
|
|
const initializer = keyProps.initializer;
|
|
if (isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, arg0, arg1, arg2));
|
|
needCompilerDiagnostic = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2));
|
|
}
|
|
}
|
|
function createDiagnosticForOptionPaths(onKey, key, message, arg0) {
|
|
let needCompilerDiagnostic = true;
|
|
const pathsSyntax = getOptionPathsSyntax();
|
|
for (const pathProp of pathsSyntax) {
|
|
if (isObjectLiteralExpression(pathProp.initializer) && createOptionDiagnosticInObjectLiteralSyntax(
|
|
pathProp.initializer,
|
|
onKey,
|
|
key,
|
|
void 0,
|
|
message,
|
|
arg0
|
|
)) {
|
|
needCompilerDiagnostic = false;
|
|
}
|
|
}
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0));
|
|
}
|
|
}
|
|
function getOptionsSyntaxByName(name) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
return compilerOptionsObjectLiteralSyntax && getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name);
|
|
}
|
|
function getOptionPathsSyntax() {
|
|
return getOptionsSyntaxByName("paths") || emptyArray;
|
|
}
|
|
function getOptionsSyntaxByValue(name, value) {
|
|
const syntaxByName = getOptionsSyntaxByName(name);
|
|
return syntaxByName && firstDefined(syntaxByName, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
|
|
}
|
|
function getOptionsSyntaxByArrayElementValue(name, value) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
return compilerOptionsObjectLiteralSyntax && getPropertyArrayElementValue(compilerOptionsObjectLiteralSyntax, name, value);
|
|
}
|
|
function createDiagnosticForOptionName(message, option1, option2, option3) {
|
|
createDiagnosticForOption(true, option1, option2, message, option1, option2, option3);
|
|
}
|
|
function createOptionValueDiagnostic(option1, message, arg0, arg1) {
|
|
createDiagnosticForOption(false, option1, void 0, message, arg0, arg1);
|
|
}
|
|
function createDiagnosticForReference(sourceFile, index, message, arg0, arg1) {
|
|
const referencesSyntax = firstDefined(
|
|
getTsConfigPropArray(sourceFile || options.configFile, "references"),
|
|
(property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
|
|
);
|
|
if (referencesSyntax && referencesSyntax.elements.length > index) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, arg0, arg1));
|
|
} else {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1));
|
|
}
|
|
}
|
|
function createDiagnosticForOption(onKey, option1, option2, message, arg0, arg1, arg2) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2);
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2));
|
|
}
|
|
}
|
|
function getCompilerOptionsObjectLiteralSyntax() {
|
|
if (_compilerOptionsObjectLiteralSyntax === void 0) {
|
|
_compilerOptionsObjectLiteralSyntax = false;
|
|
const jsonObjectLiteral = getTsConfigObjectLiteralExpression(options.configFile);
|
|
if (jsonObjectLiteral) {
|
|
for (const prop of getPropertyAssignment(jsonObjectLiteral, "compilerOptions")) {
|
|
if (isObjectLiteralExpression(prop.initializer)) {
|
|
_compilerOptionsObjectLiteralSyntax = prop.initializer;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return _compilerOptionsObjectLiteralSyntax || void 0;
|
|
}
|
|
function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2) {
|
|
const props = getPropertyAssignment(objectLiteral, key1, key2);
|
|
for (const prop of props) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2));
|
|
}
|
|
return !!props.length;
|
|
}
|
|
function blockEmittingOfFile(emitFileName, diag2) {
|
|
hasEmitBlockingDiagnostics.set(toPath3(emitFileName), true);
|
|
programDiagnostics.add(diag2);
|
|
}
|
|
function isEmittedFile(file) {
|
|
if (options.noEmit) {
|
|
return false;
|
|
}
|
|
const filePath = toPath3(file);
|
|
if (getSourceFileByPath(filePath)) {
|
|
return false;
|
|
}
|
|
const out = outFile(options);
|
|
if (out) {
|
|
return isSameFile(filePath, out) || isSameFile(filePath, removeFileExtension(out) + ".d.ts" /* Dts */);
|
|
}
|
|
if (options.declarationDir && containsPath(options.declarationDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames())) {
|
|
return true;
|
|
}
|
|
if (options.outDir) {
|
|
return containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames());
|
|
}
|
|
if (fileExtensionIsOneOf(filePath, supportedJSExtensionsFlat) || isDeclarationFileName(filePath)) {
|
|
const filePathWithoutExtension = removeFileExtension(filePath);
|
|
return !!getSourceFileByPath(filePathWithoutExtension + ".ts" /* Ts */) || !!getSourceFileByPath(filePathWithoutExtension + ".tsx" /* Tsx */);
|
|
}
|
|
return false;
|
|
}
|
|
function isSameFile(file1, file2) {
|
|
return comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === 0 /* EqualTo */;
|
|
}
|
|
function getSymlinkCache() {
|
|
if (host.getSymlinkCache) {
|
|
return host.getSymlinkCache();
|
|
}
|
|
if (!symlinks) {
|
|
symlinks = createSymlinkCache(currentDirectory, getCanonicalFileName);
|
|
}
|
|
if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
|
|
symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
|
|
}
|
|
return symlinks;
|
|
}
|
|
}
|
|
function updateHostForUseSourceOfProjectReferenceRedirect(host) {
|
|
let setOfDeclarationDirectories;
|
|
const originalFileExists = host.compilerHost.fileExists;
|
|
const originalDirectoryExists = host.compilerHost.directoryExists;
|
|
const originalGetDirectories = host.compilerHost.getDirectories;
|
|
const originalRealpath = host.compilerHost.realpath;
|
|
if (!host.useSourceOfProjectReferenceRedirect)
|
|
return { onProgramCreateComplete: noop, fileExists };
|
|
host.compilerHost.fileExists = fileExists;
|
|
let directoryExists;
|
|
if (originalDirectoryExists) {
|
|
directoryExists = host.compilerHost.directoryExists = (path) => {
|
|
if (originalDirectoryExists.call(host.compilerHost, path)) {
|
|
handleDirectoryCouldBeSymlink(path);
|
|
return true;
|
|
}
|
|
if (!host.getResolvedProjectReferences())
|
|
return false;
|
|
if (!setOfDeclarationDirectories) {
|
|
setOfDeclarationDirectories = /* @__PURE__ */ new Set();
|
|
host.forEachResolvedProjectReference((ref) => {
|
|
const out = outFile(ref.commandLine.options);
|
|
if (out) {
|
|
setOfDeclarationDirectories.add(getDirectoryPath(host.toPath(out)));
|
|
} else {
|
|
const declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir;
|
|
if (declarationDir) {
|
|
setOfDeclarationDirectories.add(host.toPath(declarationDir));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return fileOrDirectoryExistsUsingSource(path, false);
|
|
};
|
|
}
|
|
if (originalGetDirectories) {
|
|
host.compilerHost.getDirectories = (path) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path) ? originalGetDirectories.call(host.compilerHost, path) : [];
|
|
}
|
|
if (originalRealpath) {
|
|
host.compilerHost.realpath = (s) => {
|
|
var _a2;
|
|
return ((_a2 = host.getSymlinkCache().getSymlinkedFiles()) == null ? void 0 : _a2.get(host.toPath(s))) || originalRealpath.call(host.compilerHost, s);
|
|
};
|
|
}
|
|
return { onProgramCreateComplete, fileExists, directoryExists };
|
|
function onProgramCreateComplete() {
|
|
host.compilerHost.fileExists = originalFileExists;
|
|
host.compilerHost.directoryExists = originalDirectoryExists;
|
|
host.compilerHost.getDirectories = originalGetDirectories;
|
|
}
|
|
function fileExists(file) {
|
|
if (originalFileExists.call(host.compilerHost, file))
|
|
return true;
|
|
if (!host.getResolvedProjectReferences())
|
|
return false;
|
|
if (!isDeclarationFileName(file))
|
|
return false;
|
|
return fileOrDirectoryExistsUsingSource(file, true);
|
|
}
|
|
function fileExistsIfProjectReferenceDts(file) {
|
|
const source = host.getSourceOfProjectReferenceRedirect(host.toPath(file));
|
|
return source !== void 0 ? isString(source) ? originalFileExists.call(host.compilerHost, source) : true : void 0;
|
|
}
|
|
function directoryExistsIfProjectReferenceDeclDir(dir) {
|
|
const dirPath = host.toPath(dir);
|
|
const dirPathWithTrailingDirectorySeparator = `${dirPath}${directorySeparator}`;
|
|
return forEachKey(
|
|
setOfDeclarationDirectories,
|
|
(declDirPath) => dirPath === declDirPath || startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) || startsWith(dirPath, `${declDirPath}/`)
|
|
);
|
|
}
|
|
function handleDirectoryCouldBeSymlink(directory) {
|
|
var _a2;
|
|
if (!host.getResolvedProjectReferences() || containsIgnoredPath(directory))
|
|
return;
|
|
if (!originalRealpath || !stringContains(directory, nodeModulesPathPart))
|
|
return;
|
|
const symlinkCache = host.getSymlinkCache();
|
|
const directoryPath = ensureTrailingDirectorySeparator(host.toPath(directory));
|
|
if ((_a2 = symlinkCache.getSymlinkedDirectories()) == null ? void 0 : _a2.has(directoryPath))
|
|
return;
|
|
const real = normalizePath(originalRealpath.call(host.compilerHost, directory));
|
|
let realPath2;
|
|
if (real === directory || (realPath2 = ensureTrailingDirectorySeparator(host.toPath(real))) === directoryPath) {
|
|
symlinkCache.setSymlinkedDirectory(directoryPath, false);
|
|
return;
|
|
}
|
|
symlinkCache.setSymlinkedDirectory(directory, {
|
|
real: ensureTrailingDirectorySeparator(real),
|
|
realPath: realPath2
|
|
});
|
|
}
|
|
function fileOrDirectoryExistsUsingSource(fileOrDirectory, isFile) {
|
|
var _a2;
|
|
const fileOrDirectoryExistsUsingSource2 = isFile ? (file) => fileExistsIfProjectReferenceDts(file) : (dir) => directoryExistsIfProjectReferenceDeclDir(dir);
|
|
const result = fileOrDirectoryExistsUsingSource2(fileOrDirectory);
|
|
if (result !== void 0)
|
|
return result;
|
|
const symlinkCache = host.getSymlinkCache();
|
|
const symlinkedDirectories = symlinkCache.getSymlinkedDirectories();
|
|
if (!symlinkedDirectories)
|
|
return false;
|
|
const fileOrDirectoryPath = host.toPath(fileOrDirectory);
|
|
if (!stringContains(fileOrDirectoryPath, nodeModulesPathPart))
|
|
return false;
|
|
if (isFile && ((_a2 = symlinkCache.getSymlinkedFiles()) == null ? void 0 : _a2.has(fileOrDirectoryPath)))
|
|
return true;
|
|
return firstDefinedIterator(
|
|
symlinkedDirectories.entries(),
|
|
([directoryPath, symlinkedDirectory]) => {
|
|
if (!symlinkedDirectory || !startsWith(fileOrDirectoryPath, directoryPath))
|
|
return void 0;
|
|
const result2 = fileOrDirectoryExistsUsingSource2(fileOrDirectoryPath.replace(directoryPath, symlinkedDirectory.realPath));
|
|
if (isFile && result2) {
|
|
const absolutePath = getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory());
|
|
symlinkCache.setSymlinkedFile(
|
|
fileOrDirectoryPath,
|
|
`${symlinkedDirectory.real}${absolutePath.replace(new RegExp(directoryPath, "i"), "")}`
|
|
);
|
|
}
|
|
return result2;
|
|
}
|
|
) || false;
|
|
}
|
|
}
|
|
var emitSkippedWithNoDiagnostics = { diagnostics: emptyArray, sourceMaps: void 0, emittedFiles: void 0, emitSkipped: true };
|
|
function handleNoEmitOptions(program, sourceFile, writeFile2, cancellationToken) {
|
|
const options = program.getCompilerOptions();
|
|
if (options.noEmit) {
|
|
program.getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
return sourceFile || outFile(options) ? emitSkippedWithNoDiagnostics : program.emitBuildInfo(writeFile2, cancellationToken);
|
|
}
|
|
if (!options.noEmitOnError)
|
|
return void 0;
|
|
let diagnostics = [
|
|
...program.getOptionsDiagnostics(cancellationToken),
|
|
...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
|
|
...program.getGlobalDiagnostics(cancellationToken),
|
|
...program.getSemanticDiagnostics(sourceFile, cancellationToken)
|
|
];
|
|
if (diagnostics.length === 0 && getEmitDeclarations(program.getCompilerOptions())) {
|
|
diagnostics = program.getDeclarationDiagnostics(void 0, cancellationToken);
|
|
}
|
|
if (!diagnostics.length)
|
|
return void 0;
|
|
let emittedFiles;
|
|
if (!sourceFile && !outFile(options)) {
|
|
const emitResult = program.emitBuildInfo(writeFile2, cancellationToken);
|
|
if (emitResult.diagnostics)
|
|
diagnostics = [...diagnostics, ...emitResult.diagnostics];
|
|
emittedFiles = emitResult.emittedFiles;
|
|
}
|
|
return { diagnostics, sourceMaps: void 0, emittedFiles, emitSkipped: true };
|
|
}
|
|
function filterSemanticDiagnostics(diagnostic, option) {
|
|
return filter(diagnostic, (d) => !d.skippedOn || !option[d.skippedOn]);
|
|
}
|
|
function parseConfigHostFromCompilerHostLike(host, directoryStructureHost = host) {
|
|
return {
|
|
fileExists: (f) => directoryStructureHost.fileExists(f),
|
|
readDirectory(root, extensions, excludes, includes, depth) {
|
|
Debug.assertIsDefined(directoryStructureHost.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'");
|
|
return directoryStructureHost.readDirectory(root, extensions, excludes, includes, depth);
|
|
},
|
|
readFile: (f) => directoryStructureHost.readFile(f),
|
|
useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
onUnRecoverableConfigFileDiagnostic: host.onUnRecoverableConfigFileDiagnostic || returnUndefined,
|
|
trace: host.trace ? (s) => host.trace(s) : void 0
|
|
};
|
|
}
|
|
function createPrependNodes(projectReferences, getCommandLine, readFile, host) {
|
|
if (!projectReferences)
|
|
return emptyArray;
|
|
let nodes;
|
|
for (let i = 0; i < projectReferences.length; i++) {
|
|
const ref = projectReferences[i];
|
|
const resolvedRefOpts = getCommandLine(ref, i);
|
|
if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) {
|
|
const out = outFile(resolvedRefOpts.options);
|
|
if (!out)
|
|
continue;
|
|
const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(resolvedRefOpts.options, true);
|
|
const node = createInputFilesWithFilePaths(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
|
|
(nodes || (nodes = [])).push(node);
|
|
}
|
|
}
|
|
return nodes || emptyArray;
|
|
}
|
|
function resolveProjectReferencePath(hostOrRef, ref) {
|
|
const passedInRef = ref ? ref : hostOrRef;
|
|
return resolveConfigFileProjectName(passedInRef.path);
|
|
}
|
|
function getResolutionDiagnostic(options, { extension }) {
|
|
switch (extension) {
|
|
case ".ts" /* Ts */:
|
|
case ".d.ts" /* Dts */:
|
|
return void 0;
|
|
case ".tsx" /* Tsx */:
|
|
return needJsx();
|
|
case ".jsx" /* Jsx */:
|
|
return needJsx() || needAllowJs();
|
|
case ".js" /* Js */:
|
|
return needAllowJs();
|
|
case ".json" /* Json */:
|
|
return needResolveJsonModule();
|
|
}
|
|
function needJsx() {
|
|
return options.jsx ? void 0 : Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
|
|
}
|
|
function needAllowJs() {
|
|
return getAllowJSCompilerOption(options) || !getStrictOptionValue(options, "noImplicitAny") ? void 0 : Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
|
|
}
|
|
function needResolveJsonModule() {
|
|
return options.resolveJsonModule ? void 0 : Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used;
|
|
}
|
|
}
|
|
function getModuleNames({ imports, moduleAugmentations }) {
|
|
const res = imports.map((i) => i);
|
|
for (const aug of moduleAugmentations) {
|
|
if (aug.kind === 10 /* StringLiteral */) {
|
|
res.push(aug);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function getModuleNameStringLiteralAt({ imports, moduleAugmentations }, index) {
|
|
if (index < imports.length)
|
|
return imports[index];
|
|
let augIndex = imports.length;
|
|
for (const aug of moduleAugmentations) {
|
|
if (aug.kind === 10 /* StringLiteral */) {
|
|
if (index === augIndex)
|
|
return aug;
|
|
augIndex++;
|
|
}
|
|
}
|
|
Debug.fail("should never ask for module name at index higher than possible module name");
|
|
}
|
|
|
|
// src/compiler/builderState.ts
|
|
var BuilderState;
|
|
((BuilderState2) => {
|
|
function createManyToManyPathMap() {
|
|
function create2(forward, reverse, deleted) {
|
|
const map2 = {
|
|
getKeys: (v) => reverse.get(v),
|
|
getValues: (k) => forward.get(k),
|
|
keys: () => forward.keys(),
|
|
deleteKey: (k) => {
|
|
(deleted || (deleted = /* @__PURE__ */ new Set())).add(k);
|
|
const set = forward.get(k);
|
|
if (!set) {
|
|
return false;
|
|
}
|
|
set.forEach((v) => deleteFromMultimap(reverse, v, k));
|
|
forward.delete(k);
|
|
return true;
|
|
},
|
|
set: (k, vSet) => {
|
|
deleted == null ? void 0 : deleted.delete(k);
|
|
const existingVSet = forward.get(k);
|
|
forward.set(k, vSet);
|
|
existingVSet == null ? void 0 : existingVSet.forEach((v) => {
|
|
if (!vSet.has(v)) {
|
|
deleteFromMultimap(reverse, v, k);
|
|
}
|
|
});
|
|
vSet.forEach((v) => {
|
|
if (!(existingVSet == null ? void 0 : existingVSet.has(v))) {
|
|
addToMultimap(reverse, v, k);
|
|
}
|
|
});
|
|
return map2;
|
|
}
|
|
};
|
|
return map2;
|
|
}
|
|
return create2(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), void 0);
|
|
}
|
|
BuilderState2.createManyToManyPathMap = createManyToManyPathMap;
|
|
function addToMultimap(map2, k, v) {
|
|
let set = map2.get(k);
|
|
if (!set) {
|
|
set = /* @__PURE__ */ new Set();
|
|
map2.set(k, set);
|
|
}
|
|
set.add(v);
|
|
}
|
|
function deleteFromMultimap(map2, k, v) {
|
|
const set = map2.get(k);
|
|
if (set == null ? void 0 : set.delete(v)) {
|
|
if (!set.size) {
|
|
map2.delete(k);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getReferencedFilesFromImportedModuleSymbol(symbol) {
|
|
return mapDefined(symbol.declarations, (declaration) => {
|
|
var _a2;
|
|
return (_a2 = getSourceFileOfNode(declaration)) == null ? void 0 : _a2.resolvedPath;
|
|
});
|
|
}
|
|
function getReferencedFilesFromImportLiteral(checker, importName) {
|
|
const symbol = checker.getSymbolAtLocation(importName);
|
|
return symbol && getReferencedFilesFromImportedModuleSymbol(symbol);
|
|
}
|
|
function getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName) {
|
|
return toPath(program.getProjectReferenceRedirect(fileName) || fileName, sourceFileDirectory, getCanonicalFileName);
|
|
}
|
|
function getReferencedFiles(program, sourceFile, getCanonicalFileName) {
|
|
let referencedFiles;
|
|
if (sourceFile.imports && sourceFile.imports.length > 0) {
|
|
const checker = program.getTypeChecker();
|
|
for (const importName of sourceFile.imports) {
|
|
const declarationSourceFilePaths = getReferencedFilesFromImportLiteral(checker, importName);
|
|
declarationSourceFilePaths == null ? void 0 : declarationSourceFilePaths.forEach(addReferencedFile);
|
|
}
|
|
}
|
|
const sourceFileDirectory = getDirectoryPath(sourceFile.resolvedPath);
|
|
if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) {
|
|
for (const referencedFile of sourceFile.referencedFiles) {
|
|
const referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);
|
|
addReferencedFile(referencedPath);
|
|
}
|
|
}
|
|
if (sourceFile.resolvedTypeReferenceDirectiveNames) {
|
|
sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
|
|
if (!resolvedTypeReferenceDirective) {
|
|
return;
|
|
}
|
|
const fileName = resolvedTypeReferenceDirective.resolvedFileName;
|
|
const typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName);
|
|
addReferencedFile(typeFilePath);
|
|
});
|
|
}
|
|
if (sourceFile.moduleAugmentations.length) {
|
|
const checker = program.getTypeChecker();
|
|
for (const moduleName of sourceFile.moduleAugmentations) {
|
|
if (!isStringLiteral(moduleName))
|
|
continue;
|
|
const symbol = checker.getSymbolAtLocation(moduleName);
|
|
if (!symbol)
|
|
continue;
|
|
addReferenceFromAmbientModule(symbol);
|
|
}
|
|
}
|
|
for (const ambientModule of program.getTypeChecker().getAmbientModules()) {
|
|
if (ambientModule.declarations && ambientModule.declarations.length > 1) {
|
|
addReferenceFromAmbientModule(ambientModule);
|
|
}
|
|
}
|
|
return referencedFiles;
|
|
function addReferenceFromAmbientModule(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
const declarationSourceFile = getSourceFileOfNode(declaration);
|
|
if (declarationSourceFile && declarationSourceFile !== sourceFile) {
|
|
addReferencedFile(declarationSourceFile.resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
function addReferencedFile(referencedPath) {
|
|
(referencedFiles || (referencedFiles = /* @__PURE__ */ new Set())).add(referencedPath);
|
|
}
|
|
}
|
|
function canReuseOldState(newReferencedMap, oldState) {
|
|
return oldState && !oldState.referencedMap === !newReferencedMap;
|
|
}
|
|
BuilderState2.canReuseOldState = canReuseOldState;
|
|
function create(newProgram, oldState, disableUseFileVersionAsSignature) {
|
|
var _a2, _b, _c;
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
const options = newProgram.getCompilerOptions();
|
|
const isOutFile = outFile(options);
|
|
const referencedMap = options.module !== 0 /* None */ && !isOutFile ? createManyToManyPathMap() : void 0;
|
|
const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
|
|
const useOldState = canReuseOldState(referencedMap, oldState);
|
|
const getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames());
|
|
newProgram.getTypeChecker();
|
|
for (const sourceFile of newProgram.getSourceFiles()) {
|
|
const version2 = Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
|
|
const oldUncommittedSignature = useOldState ? (_a2 = oldState.oldSignatures) == null ? void 0 : _a2.get(sourceFile.resolvedPath) : void 0;
|
|
const signature = oldUncommittedSignature === void 0 ? useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) == null ? void 0 : _b.signature : void 0 : oldUncommittedSignature || void 0;
|
|
if (referencedMap) {
|
|
const newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName);
|
|
if (newReferences) {
|
|
referencedMap.set(sourceFile.resolvedPath, newReferences);
|
|
}
|
|
if (useOldState) {
|
|
const oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) == null ? void 0 : _c.get(sourceFile.resolvedPath);
|
|
const exportedModules = oldUncommittedExportedModules === void 0 ? oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) : oldUncommittedExportedModules || void 0;
|
|
if (exportedModules) {
|
|
exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
|
|
}
|
|
}
|
|
}
|
|
fileInfos.set(sourceFile.resolvedPath, {
|
|
version: version2,
|
|
signature,
|
|
affectsGlobalScope: !isOutFile ? isFileAffectingGlobalScope(sourceFile) || void 0 : void 0,
|
|
impliedFormat: sourceFile.impliedNodeFormat
|
|
});
|
|
}
|
|
return {
|
|
fileInfos,
|
|
referencedMap,
|
|
exportedModulesMap,
|
|
useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
|
|
};
|
|
}
|
|
BuilderState2.create = create;
|
|
function releaseCache2(state) {
|
|
state.allFilesExcludingDefaultLibraryFile = void 0;
|
|
state.allFileNames = void 0;
|
|
}
|
|
BuilderState2.releaseCache = releaseCache2;
|
|
function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
|
|
var _a2, _b;
|
|
const result = getFilesAffectedByWithOldState(
|
|
state,
|
|
programOfThisState,
|
|
path,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
(_a2 = state.oldSignatures) == null ? void 0 : _a2.clear();
|
|
(_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
|
|
return result;
|
|
}
|
|
BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
|
|
function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host) {
|
|
const sourceFile = programOfThisState.getSourceFileByPath(path);
|
|
if (!sourceFile) {
|
|
return emptyArray;
|
|
}
|
|
if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
|
|
return [sourceFile];
|
|
}
|
|
return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
|
|
}
|
|
BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
|
|
function updateSignatureOfFile(state, signature, path) {
|
|
state.fileInfos.get(path).signature = signature;
|
|
(state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path);
|
|
}
|
|
BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
|
|
function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature = state.useFileVersionAsSignature) {
|
|
var _a2;
|
|
if ((_a2 = state.hasCalledUpdateShapeSignature) == null ? void 0 : _a2.has(sourceFile.resolvedPath))
|
|
return false;
|
|
const info = state.fileInfos.get(sourceFile.resolvedPath);
|
|
const prevSignature = info.signature;
|
|
let latestSignature;
|
|
if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
|
|
programOfThisState.emit(
|
|
sourceFile,
|
|
(fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
|
|
Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
|
|
latestSignature = computeSignatureWithDiagnostics(
|
|
programOfThisState,
|
|
sourceFile,
|
|
text,
|
|
host,
|
|
data
|
|
);
|
|
if (latestSignature !== prevSignature) {
|
|
updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
|
|
}
|
|
},
|
|
cancellationToken,
|
|
true,
|
|
void 0,
|
|
true
|
|
);
|
|
}
|
|
if (latestSignature === void 0) {
|
|
latestSignature = sourceFile.version;
|
|
if (state.exportedModulesMap && latestSignature !== prevSignature) {
|
|
(state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
|
|
const references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : void 0;
|
|
if (references) {
|
|
state.exportedModulesMap.set(sourceFile.resolvedPath, references);
|
|
} else {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
(state.oldSignatures || (state.oldSignatures = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, prevSignature || false);
|
|
(state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(sourceFile.resolvedPath);
|
|
info.signature = latestSignature;
|
|
return latestSignature !== prevSignature;
|
|
}
|
|
BuilderState2.updateShapeSignature = updateShapeSignature;
|
|
function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
|
|
if (!state.exportedModulesMap)
|
|
return;
|
|
(state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
|
|
if (!exportedModulesFromDeclarationEmit) {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
return;
|
|
}
|
|
let exportedModules;
|
|
exportedModulesFromDeclarationEmit.forEach((symbol) => addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)));
|
|
if (exportedModules) {
|
|
state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
|
|
} else {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
}
|
|
function addExportedModule(exportedModulePaths) {
|
|
if (exportedModulePaths == null ? void 0 : exportedModulePaths.length) {
|
|
if (!exportedModules) {
|
|
exportedModules = /* @__PURE__ */ new Set();
|
|
}
|
|
exportedModulePaths.forEach((path) => exportedModules.add(path));
|
|
}
|
|
}
|
|
}
|
|
BuilderState2.updateExportedModules = updateExportedModules;
|
|
function getAllDependencies(state, programOfThisState, sourceFile) {
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
return getAllFileNames(state, programOfThisState);
|
|
}
|
|
if (!state.referencedMap || isFileAffectingGlobalScope(sourceFile)) {
|
|
return getAllFileNames(state, programOfThisState);
|
|
}
|
|
const seenMap = /* @__PURE__ */ new Set();
|
|
const queue = [sourceFile.resolvedPath];
|
|
while (queue.length) {
|
|
const path = queue.pop();
|
|
if (!seenMap.has(path)) {
|
|
seenMap.add(path);
|
|
const references = state.referencedMap.getValues(path);
|
|
if (references) {
|
|
const iterator = references.keys();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
queue.push(iterResult.value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(mapDefinedIterator(seenMap.keys(), (path) => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = programOfThisState.getSourceFileByPath(path)) == null ? void 0 : _a2.fileName) != null ? _b : path;
|
|
}));
|
|
}
|
|
BuilderState2.getAllDependencies = getAllDependencies;
|
|
function getAllFileNames(state, programOfThisState) {
|
|
if (!state.allFileNames) {
|
|
const sourceFiles = programOfThisState.getSourceFiles();
|
|
state.allFileNames = sourceFiles === emptyArray ? emptyArray : sourceFiles.map((file) => file.fileName);
|
|
}
|
|
return state.allFileNames;
|
|
}
|
|
function getReferencedByPaths(state, referencedFilePath) {
|
|
const keys = state.referencedMap.getKeys(referencedFilePath);
|
|
return keys ? arrayFrom(keys.keys()) : [];
|
|
}
|
|
BuilderState2.getReferencedByPaths = getReferencedByPaths;
|
|
function containsOnlyAmbientModules(sourceFile) {
|
|
for (const statement of sourceFile.statements) {
|
|
if (!isModuleWithStringLiteralName(statement)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function containsGlobalScopeAugmentation(sourceFile) {
|
|
return some(sourceFile.moduleAugmentations, (augmentation) => isGlobalScopeAugmentation(augmentation.parent));
|
|
}
|
|
function isFileAffectingGlobalScope(sourceFile) {
|
|
return containsGlobalScopeAugmentation(sourceFile) || !isExternalOrCommonJsModule(sourceFile) && !isJsonSourceFile(sourceFile) && !containsOnlyAmbientModules(sourceFile);
|
|
}
|
|
function getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, firstSourceFile) {
|
|
if (state.allFilesExcludingDefaultLibraryFile) {
|
|
return state.allFilesExcludingDefaultLibraryFile;
|
|
}
|
|
let result;
|
|
if (firstSourceFile)
|
|
addSourceFile(firstSourceFile);
|
|
for (const sourceFile of programOfThisState.getSourceFiles()) {
|
|
if (sourceFile !== firstSourceFile) {
|
|
addSourceFile(sourceFile);
|
|
}
|
|
}
|
|
state.allFilesExcludingDefaultLibraryFile = result || emptyArray;
|
|
return state.allFilesExcludingDefaultLibraryFile;
|
|
function addSourceFile(sourceFile) {
|
|
if (!programOfThisState.isSourceFileDefaultLibrary(sourceFile)) {
|
|
(result || (result = [])).push(sourceFile);
|
|
}
|
|
}
|
|
}
|
|
BuilderState2.getAllFilesExcludingDefaultLibraryFile = getAllFilesExcludingDefaultLibraryFile;
|
|
function getFilesAffectedByUpdatedShapeWhenNonModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape) {
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (compilerOptions && outFile(compilerOptions)) {
|
|
return [sourceFileWithUpdatedShape];
|
|
}
|
|
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
|
|
}
|
|
function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, host) {
|
|
if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
|
|
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
|
|
}
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (compilerOptions && (compilerOptions.isolatedModules || outFile(compilerOptions))) {
|
|
return [sourceFileWithUpdatedShape];
|
|
}
|
|
const seenFileNamesMap = /* @__PURE__ */ new Map();
|
|
seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape);
|
|
const queue = getReferencedByPaths(state, sourceFileWithUpdatedShape.resolvedPath);
|
|
while (queue.length > 0) {
|
|
const currentPath = queue.pop();
|
|
if (!seenFileNamesMap.has(currentPath)) {
|
|
const currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
|
|
seenFileNamesMap.set(currentPath, currentSourceFile);
|
|
if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
|
|
queue.push(...getReferencedByPaths(state, currentSourceFile.resolvedPath));
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(mapDefinedIterator(seenFileNamesMap.values(), (value) => value));
|
|
}
|
|
})(BuilderState || (BuilderState = {}));
|
|
|
|
// src/compiler/builder.ts
|
|
function getBuilderFileEmit(options) {
|
|
let result = 1 /* Js */;
|
|
if (options.sourceMap)
|
|
result = result | 2 /* JsMap */;
|
|
if (options.inlineSourceMap)
|
|
result = result | 4 /* JsInlineMap */;
|
|
if (getEmitDeclarations(options))
|
|
result = result | 8 /* Dts */;
|
|
if (options.declarationMap)
|
|
result = result | 16 /* DtsMap */;
|
|
if (options.emitDeclarationOnly)
|
|
result = result & 24 /* AllDts */;
|
|
return result;
|
|
}
|
|
function getPendingEmitKind(optionsOrEmitKind, oldOptionsOrEmitKind) {
|
|
const oldEmitKind = oldOptionsOrEmitKind && (isNumber(oldOptionsOrEmitKind) ? oldOptionsOrEmitKind : getBuilderFileEmit(oldOptionsOrEmitKind));
|
|
const emitKind = isNumber(optionsOrEmitKind) ? optionsOrEmitKind : getBuilderFileEmit(optionsOrEmitKind);
|
|
if (oldEmitKind === emitKind)
|
|
return 0 /* None */;
|
|
if (!oldEmitKind || !emitKind)
|
|
return emitKind;
|
|
const diff = oldEmitKind ^ emitKind;
|
|
let result = 0 /* None */;
|
|
if (diff & 7 /* AllJs */)
|
|
result = emitKind & 7 /* AllJs */;
|
|
if (diff & 24 /* AllDts */)
|
|
result = result | emitKind & 24 /* AllDts */;
|
|
return result;
|
|
}
|
|
function hasSameKeys(map1, map2) {
|
|
return map1 === map2 || map1 !== void 0 && map2 !== void 0 && map1.size === map2.size && !forEachKey(map1, (key) => !map2.has(key));
|
|
}
|
|
function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
|
|
var _a2, _b;
|
|
const state = BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
|
|
state.program = newProgram;
|
|
const compilerOptions = newProgram.getCompilerOptions();
|
|
state.compilerOptions = compilerOptions;
|
|
const outFilePath = outFile(compilerOptions);
|
|
if (!outFilePath) {
|
|
state.semanticDiagnosticsPerFile = /* @__PURE__ */ new Map();
|
|
} else if (compilerOptions.composite && (oldState == null ? void 0 : oldState.outSignature) && outFilePath === outFile(oldState == null ? void 0 : oldState.compilerOptions)) {
|
|
state.outSignature = oldState.outSignature && getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, oldState.outSignature);
|
|
}
|
|
state.changedFilesSet = /* @__PURE__ */ new Set();
|
|
state.latestChangedDtsFile = compilerOptions.composite ? oldState == null ? void 0 : oldState.latestChangedDtsFile : void 0;
|
|
const useOldState = BuilderState.canReuseOldState(state.referencedMap, oldState);
|
|
const oldCompilerOptions = useOldState ? oldState.compilerOptions : void 0;
|
|
const canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile && !compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
|
|
const canCopyEmitSignatures = compilerOptions.composite && (oldState == null ? void 0 : oldState.emitSignatures) && !outFilePath && !compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions);
|
|
if (useOldState) {
|
|
(_a2 = oldState.changedFilesSet) == null ? void 0 : _a2.forEach((value) => state.changedFilesSet.add(value));
|
|
if (!outFilePath && ((_b = oldState.affectedFilesPendingEmit) == null ? void 0 : _b.size)) {
|
|
state.affectedFilesPendingEmit = new Map(oldState.affectedFilesPendingEmit);
|
|
state.seenAffectedFiles = /* @__PURE__ */ new Set();
|
|
}
|
|
state.programEmitPending = oldState.programEmitPending;
|
|
} else {
|
|
state.buildInfoEmitPending = true;
|
|
}
|
|
const referencedMap = state.referencedMap;
|
|
const oldReferencedMap = useOldState ? oldState.referencedMap : void 0;
|
|
const copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck;
|
|
const copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck;
|
|
state.fileInfos.forEach((info, sourceFilePath) => {
|
|
var _a3;
|
|
let oldInfo;
|
|
let newReferences;
|
|
if (!useOldState || !(oldInfo = oldState.fileInfos.get(sourceFilePath)) || oldInfo.version !== info.version || oldInfo.impliedFormat !== info.impliedFormat || !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || newReferences && forEachKey(newReferences, (path) => !state.fileInfos.has(path) && oldState.fileInfos.has(path))) {
|
|
addFileToChangeSet(state, sourceFilePath);
|
|
} else if (canCopySemanticDiagnostics) {
|
|
const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
|
|
if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
|
|
return;
|
|
if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
|
|
return;
|
|
const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
|
|
if (diagnostics) {
|
|
state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : diagnostics);
|
|
if (!state.semanticDiagnosticsFromOldState) {
|
|
state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set();
|
|
}
|
|
state.semanticDiagnosticsFromOldState.add(sourceFilePath);
|
|
}
|
|
}
|
|
if (canCopyEmitSignatures) {
|
|
const oldEmitSignature = oldState.emitSignatures.get(sourceFilePath);
|
|
if (oldEmitSignature) {
|
|
((_a3 = state.emitSignatures) != null ? _a3 : state.emitSignatures = /* @__PURE__ */ new Map()).set(sourceFilePath, getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, oldEmitSignature));
|
|
}
|
|
}
|
|
});
|
|
if (useOldState && forEachEntry(oldState.fileInfos, (info, sourceFilePath) => {
|
|
if (state.fileInfos.has(sourceFilePath))
|
|
return false;
|
|
if (outFilePath || info.affectsGlobalScope)
|
|
return true;
|
|
state.buildInfoEmitPending = true;
|
|
return false;
|
|
})) {
|
|
BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, void 0).forEach((file) => addFileToChangeSet(state, file.resolvedPath));
|
|
} else if (oldCompilerOptions) {
|
|
const pendingEmitKind = compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions) ? getBuilderFileEmit(compilerOptions) : getPendingEmitKind(compilerOptions, oldCompilerOptions);
|
|
if (pendingEmitKind !== 0 /* None */) {
|
|
if (!outFilePath) {
|
|
newProgram.getSourceFiles().forEach((f) => {
|
|
if (!state.changedFilesSet.has(f.resolvedPath)) {
|
|
addToAffectedFilesPendingEmit(
|
|
state,
|
|
f.resolvedPath,
|
|
pendingEmitKind
|
|
);
|
|
}
|
|
});
|
|
Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
|
|
state.seenAffectedFiles = state.seenAffectedFiles || /* @__PURE__ */ new Set();
|
|
state.buildInfoEmitPending = true;
|
|
} else {
|
|
state.programEmitPending = state.programEmitPending ? state.programEmitPending | pendingEmitKind : pendingEmitKind;
|
|
}
|
|
}
|
|
}
|
|
if (outFilePath && !state.changedFilesSet.size) {
|
|
if (useOldState)
|
|
state.bundle = oldState.bundle;
|
|
if (some(newProgram.getProjectReferences(), (ref) => !!ref.prepend))
|
|
state.programEmitPending = getBuilderFileEmit(compilerOptions);
|
|
}
|
|
return state;
|
|
}
|
|
function addFileToChangeSet(state, path) {
|
|
state.changedFilesSet.add(path);
|
|
state.buildInfoEmitPending = true;
|
|
state.programEmitPending = void 0;
|
|
}
|
|
function getEmitSignatureFromOldSignature(options, oldOptions, oldEmitSignature) {
|
|
return !!options.declarationMap === !!oldOptions.declarationMap ? oldEmitSignature : isString(oldEmitSignature) ? [oldEmitSignature] : oldEmitSignature[0];
|
|
}
|
|
function convertToDiagnostics(diagnostics, newProgram) {
|
|
if (!diagnostics.length)
|
|
return emptyArray;
|
|
let buildInfoDirectory;
|
|
let getCanonicalFileName;
|
|
return diagnostics.map((diagnostic) => {
|
|
const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3);
|
|
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
|
|
result.reportsDeprecated = diagnostic.reportDeprecated;
|
|
result.source = diagnostic.source;
|
|
result.skippedOn = diagnostic.skippedOn;
|
|
const { relatedInformation } = diagnostic;
|
|
result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPath3)) : [] : void 0;
|
|
return result;
|
|
});
|
|
function toPath3(path) {
|
|
buildInfoDirectory != null ? buildInfoDirectory : buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
|
|
return toPath(path, buildInfoDirectory, getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames()));
|
|
}
|
|
}
|
|
function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3) {
|
|
const { file } = diagnostic;
|
|
return {
|
|
...diagnostic,
|
|
file: file ? newProgram.getSourceFileByPath(toPath3(file)) : void 0
|
|
};
|
|
}
|
|
function releaseCache(state) {
|
|
BuilderState.releaseCache(state);
|
|
state.program = void 0;
|
|
}
|
|
function backupBuilderProgramEmitState(state) {
|
|
const outFilePath = outFile(state.compilerOptions);
|
|
Debug.assert(!state.changedFilesSet.size || outFilePath);
|
|
return {
|
|
affectedFilesPendingEmit: state.affectedFilesPendingEmit && new Map(state.affectedFilesPendingEmit),
|
|
seenEmittedFiles: state.seenEmittedFiles && new Map(state.seenEmittedFiles),
|
|
programEmitPending: state.programEmitPending,
|
|
emitSignatures: state.emitSignatures && new Map(state.emitSignatures),
|
|
outSignature: state.outSignature,
|
|
latestChangedDtsFile: state.latestChangedDtsFile,
|
|
hasChangedEmitSignature: state.hasChangedEmitSignature,
|
|
changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0
|
|
};
|
|
}
|
|
function restoreBuilderProgramEmitState(state, savedEmitState) {
|
|
state.affectedFilesPendingEmit = savedEmitState.affectedFilesPendingEmit;
|
|
state.seenEmittedFiles = savedEmitState.seenEmittedFiles;
|
|
state.programEmitPending = savedEmitState.programEmitPending;
|
|
state.emitSignatures = savedEmitState.emitSignatures;
|
|
state.outSignature = savedEmitState.outSignature;
|
|
state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;
|
|
state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
|
|
if (savedEmitState.changedFilesSet)
|
|
state.changedFilesSet = savedEmitState.changedFilesSet;
|
|
}
|
|
function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
|
|
Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
|
|
}
|
|
function getNextAffectedFile(state, cancellationToken, host) {
|
|
var _a2, _b;
|
|
while (true) {
|
|
const { affectedFiles } = state;
|
|
if (affectedFiles) {
|
|
const seenAffectedFiles = state.seenAffectedFiles;
|
|
let affectedFilesIndex = state.affectedFilesIndex;
|
|
while (affectedFilesIndex < affectedFiles.length) {
|
|
const affectedFile = affectedFiles[affectedFilesIndex];
|
|
if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
|
|
state.affectedFilesIndex = affectedFilesIndex;
|
|
addToAffectedFilesPendingEmit(state, affectedFile.resolvedPath, getBuilderFileEmit(state.compilerOptions));
|
|
handleDtsMayChangeOfAffectedFile(
|
|
state,
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
return affectedFile;
|
|
}
|
|
affectedFilesIndex++;
|
|
}
|
|
state.changedFilesSet.delete(state.currentChangedFilePath);
|
|
state.currentChangedFilePath = void 0;
|
|
(_a2 = state.oldSignatures) == null ? void 0 : _a2.clear();
|
|
(_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
|
|
state.affectedFiles = void 0;
|
|
}
|
|
const nextKey = state.changedFilesSet.keys().next();
|
|
if (nextKey.done) {
|
|
return void 0;
|
|
}
|
|
const program = Debug.checkDefined(state.program);
|
|
const compilerOptions = program.getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
Debug.assert(!state.semanticDiagnosticsPerFile);
|
|
return program;
|
|
}
|
|
state.affectedFiles = BuilderState.getFilesAffectedByWithOldState(
|
|
state,
|
|
program,
|
|
nextKey.value,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
state.currentChangedFilePath = nextKey.value;
|
|
state.affectedFilesIndex = 0;
|
|
if (!state.seenAffectedFiles)
|
|
state.seenAffectedFiles = /* @__PURE__ */ new Set();
|
|
}
|
|
}
|
|
function clearAffectedFilesPendingEmit(state, emitOnlyDtsFiles) {
|
|
var _a2;
|
|
if (!((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.size))
|
|
return;
|
|
if (!emitOnlyDtsFiles)
|
|
return state.affectedFilesPendingEmit = void 0;
|
|
state.affectedFilesPendingEmit.forEach((emitKind, path) => {
|
|
const pending = emitKind & 7 /* AllJs */;
|
|
if (!pending)
|
|
state.affectedFilesPendingEmit.delete(path);
|
|
else
|
|
state.affectedFilesPendingEmit.set(path, pending);
|
|
});
|
|
}
|
|
function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles) {
|
|
var _a2;
|
|
if (!((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.size))
|
|
return void 0;
|
|
return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path) => {
|
|
var _a3;
|
|
const affectedFile = state.program.getSourceFileByPath(path);
|
|
if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
|
|
state.affectedFilesPendingEmit.delete(path);
|
|
return void 0;
|
|
}
|
|
const seenKind = (_a3 = state.seenEmittedFiles) == null ? void 0 : _a3.get(affectedFile.resolvedPath);
|
|
let pendingKind = getPendingEmitKind(emitKind, seenKind);
|
|
if (emitOnlyDtsFiles)
|
|
pendingKind = pendingKind & 24 /* AllDts */;
|
|
if (pendingKind)
|
|
return { affectedFile, emitKind: pendingKind };
|
|
});
|
|
}
|
|
function removeDiagnosticsOfLibraryFiles(state) {
|
|
if (!state.cleanedDiagnosticsOfLibFiles) {
|
|
state.cleanedDiagnosticsOfLibFiles = true;
|
|
const program = Debug.checkDefined(state.program);
|
|
const options = program.getCompilerOptions();
|
|
forEach(
|
|
program.getSourceFiles(),
|
|
(f) => program.isSourceFileDefaultLibrary(f) && !skipTypeChecking(f, options, program) && removeSemanticDiagnosticsOf(state, f.resolvedPath)
|
|
);
|
|
}
|
|
}
|
|
function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host) {
|
|
removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
|
|
if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
|
|
removeDiagnosticsOfLibraryFiles(state);
|
|
BuilderState.updateShapeSignature(
|
|
state,
|
|
Debug.checkDefined(state.program),
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
return;
|
|
}
|
|
if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
|
|
return;
|
|
handleDtsMayChangeOfReferencingExportOfAffectedFile(
|
|
state,
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
}
|
|
function handleDtsMayChangeOf(state, path, cancellationToken, host) {
|
|
removeSemanticDiagnosticsOf(state, path);
|
|
if (!state.changedFilesSet.has(path)) {
|
|
const program = Debug.checkDefined(state.program);
|
|
const sourceFile = program.getSourceFileByPath(path);
|
|
if (sourceFile) {
|
|
BuilderState.updateShapeSignature(
|
|
state,
|
|
program,
|
|
sourceFile,
|
|
cancellationToken,
|
|
host,
|
|
!host.disableUseFileVersionAsSignature
|
|
);
|
|
if (getEmitDeclarations(state.compilerOptions)) {
|
|
addToAffectedFilesPendingEmit(state, path, state.compilerOptions.declarationMap ? 24 /* AllDts */ : 8 /* Dts */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
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) {
|
|
const oldSignature = Debug.checkDefined(state.oldSignatures).get(path) || void 0;
|
|
const newSignature = Debug.checkDefined(state.fileInfos.get(path)).signature;
|
|
return newSignature !== oldSignature;
|
|
}
|
|
function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host) {
|
|
var _a2;
|
|
if (!((_a2 = state.fileInfos.get(filePath)) == null ? void 0 : _a2.affectsGlobalScope))
|
|
return false;
|
|
BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, void 0).forEach((file) => handleDtsMayChangeOf(
|
|
state,
|
|
file.resolvedPath,
|
|
cancellationToken,
|
|
host
|
|
));
|
|
removeDiagnosticsOfLibraryFiles(state);
|
|
return true;
|
|
}
|
|
function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
|
|
var _a2;
|
|
if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
|
|
return;
|
|
if (!isChangedSignature(state, affectedFile.resolvedPath))
|
|
return;
|
|
if (state.compilerOptions.isolatedModules) {
|
|
const seenFileNamesMap = /* @__PURE__ */ new Map();
|
|
seenFileNamesMap.set(affectedFile.resolvedPath, true);
|
|
const queue = BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);
|
|
while (queue.length > 0) {
|
|
const currentPath = queue.pop();
|
|
if (!seenFileNamesMap.has(currentPath)) {
|
|
seenFileNamesMap.set(currentPath, true);
|
|
if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, host))
|
|
return;
|
|
handleDtsMayChangeOf(state, currentPath, cancellationToken, host);
|
|
if (isChangedSignature(state, currentPath)) {
|
|
const currentSourceFile = Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
|
|
queue.push(...BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const seenFileAndExportsOfFile = /* @__PURE__ */ new Set();
|
|
(_a2 = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a2.forEach((exportedFromPath) => {
|
|
if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
|
|
return true;
|
|
const references = state.referencedMap.getKeys(exportedFromPath);
|
|
return references && forEachKey(
|
|
references,
|
|
(filePath) => handleDtsMayChangeOfFileAndExportsOfFile(
|
|
state,
|
|
filePath,
|
|
seenFileAndExportsOfFile,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
});
|
|
}
|
|
function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
|
|
var _a2, _b;
|
|
if (!tryAddToSet(seenFileAndExportsOfFile, filePath))
|
|
return void 0;
|
|
if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
|
|
return true;
|
|
handleDtsMayChangeOf(state, filePath, cancellationToken, host);
|
|
(_a2 = state.exportedModulesMap.getKeys(filePath)) == null ? void 0 : _a2.forEach(
|
|
(exportedFromPath) => handleDtsMayChangeOfFileAndExportsOfFile(
|
|
state,
|
|
exportedFromPath,
|
|
seenFileAndExportsOfFile,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
(_b = state.referencedMap.getKeys(filePath)) == null ? void 0 : _b.forEach(
|
|
(referencingFilePath) => !seenFileAndExportsOfFile.has(referencingFilePath) && handleDtsMayChangeOf(
|
|
state,
|
|
referencingFilePath,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
return void 0;
|
|
}
|
|
function getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken) {
|
|
return concatenate(
|
|
getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken),
|
|
Debug.checkDefined(state.program).getProgramDiagnostics(sourceFile)
|
|
);
|
|
}
|
|
function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken) {
|
|
const path = sourceFile.resolvedPath;
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
const cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path);
|
|
if (cachedDiagnostics) {
|
|
return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
|
|
}
|
|
}
|
|
const diagnostics = Debug.checkDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken);
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
state.semanticDiagnosticsPerFile.set(path, diagnostics);
|
|
}
|
|
return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
|
|
}
|
|
function isProgramBundleEmitBuildInfo(info) {
|
|
return !!outFile(info.options || {});
|
|
}
|
|
function getBuildInfo2(state, bundle) {
|
|
var _a2, _b, _c;
|
|
const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
|
|
const getCanonicalFileName = createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
|
|
const latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : void 0;
|
|
const fileNames = [];
|
|
const fileNameToFileId = /* @__PURE__ */ new Map();
|
|
if (outFile(state.compilerOptions)) {
|
|
const fileInfos2 = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
|
|
toFileId(key);
|
|
return value.impliedFormat ? { version: value.version, impliedFormat: value.impliedFormat, signature: void 0, affectsGlobalScope: void 0 } : value.version;
|
|
});
|
|
const program2 = {
|
|
fileNames,
|
|
fileInfos: fileInfos2,
|
|
options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
|
|
outSignature: state.outSignature,
|
|
latestChangedDtsFile,
|
|
pendingEmit: !state.programEmitPending ? void 0 : state.programEmitPending === getBuilderFileEmit(state.compilerOptions) ? false : state.programEmitPending
|
|
};
|
|
const { js, dts, commonSourceDirectory, sourceFiles } = bundle;
|
|
state.bundle = bundle = {
|
|
commonSourceDirectory,
|
|
sourceFiles,
|
|
js: js || (!state.compilerOptions.emitDeclarationOnly ? (_a2 = state.bundle) == null ? void 0 : _a2.js : void 0),
|
|
dts: dts || (getEmitDeclarations(state.compilerOptions) ? (_b = state.bundle) == null ? void 0 : _b.dts : void 0)
|
|
};
|
|
return createBuildInfo(program2, bundle);
|
|
}
|
|
let fileIdsList;
|
|
let fileNamesToFileIdListId;
|
|
let emitSignatures;
|
|
const fileInfos = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
|
|
var _a3, _b2;
|
|
const fileId = toFileId(key);
|
|
Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key));
|
|
const oldSignature = (_a3 = state.oldSignatures) == null ? void 0 : _a3.get(key);
|
|
const actualSignature = oldSignature !== void 0 ? oldSignature || void 0 : value.signature;
|
|
if (state.compilerOptions.composite) {
|
|
const file = state.program.getSourceFileByPath(key);
|
|
if (!isJsonSourceFile(file) && sourceFileMayBeEmitted(file, state.program)) {
|
|
const emitSignature = (_b2 = state.emitSignatures) == null ? void 0 : _b2.get(key);
|
|
if (emitSignature !== actualSignature) {
|
|
(emitSignatures || (emitSignatures = [])).push(emitSignature === void 0 ? fileId : [fileId, !isString(emitSignature) && emitSignature[0] === actualSignature ? emptyArray : emitSignature]);
|
|
}
|
|
}
|
|
}
|
|
return value.version === actualSignature ? value.affectsGlobalScope || value.impliedFormat ? { version: value.version, signature: void 0, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : value.version : actualSignature !== void 0 ? oldSignature === void 0 ? value : { version: value.version, signature: actualSignature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
|
|
});
|
|
let referencedMap;
|
|
if (state.referencedMap) {
|
|
referencedMap = arrayFrom(state.referencedMap.keys()).sort(compareStringsCaseSensitive).map((key) => [
|
|
toFileId(key),
|
|
toFileIdListId(state.referencedMap.getValues(key))
|
|
]);
|
|
}
|
|
let exportedModulesMap;
|
|
if (state.exportedModulesMap) {
|
|
exportedModulesMap = mapDefined(arrayFrom(state.exportedModulesMap.keys()).sort(compareStringsCaseSensitive), (key) => {
|
|
var _a3;
|
|
const oldValue = (_a3 = state.oldExportedModulesMap) == null ? void 0 : _a3.get(key);
|
|
if (oldValue === void 0)
|
|
return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
|
|
if (oldValue)
|
|
return [toFileId(key), toFileIdListId(oldValue)];
|
|
return void 0;
|
|
});
|
|
}
|
|
let semanticDiagnosticsPerFile;
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
for (const key of arrayFrom(state.semanticDiagnosticsPerFile.keys()).sort(compareStringsCaseSensitive)) {
|
|
const value = state.semanticDiagnosticsPerFile.get(key);
|
|
(semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(
|
|
value.length ? [
|
|
toFileId(key),
|
|
convertToReusableDiagnostics(value, relativeToBuildInfo)
|
|
] : toFileId(key)
|
|
);
|
|
}
|
|
}
|
|
let affectedFilesPendingEmit;
|
|
if ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.size) {
|
|
const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
|
|
const seenFiles = /* @__PURE__ */ new Set();
|
|
for (const path of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
|
|
if (tryAddToSet(seenFiles, path)) {
|
|
const file = state.program.getSourceFileByPath(path);
|
|
if (!sourceFileMayBeEmitted(file, state.program))
|
|
continue;
|
|
const fileId = toFileId(path), pendingEmit = state.affectedFilesPendingEmit.get(path);
|
|
(affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(
|
|
pendingEmit === fullEmitForOptions ? fileId : pendingEmit === 8 /* Dts */ ? [fileId] : [fileId, pendingEmit]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
let changeFileSet;
|
|
if (state.changedFilesSet.size) {
|
|
for (const path of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
|
|
(changeFileSet || (changeFileSet = [])).push(toFileId(path));
|
|
}
|
|
}
|
|
const program = {
|
|
fileNames,
|
|
fileInfos,
|
|
options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
|
|
fileIdsList,
|
|
referencedMap,
|
|
exportedModulesMap,
|
|
semanticDiagnosticsPerFile,
|
|
affectedFilesPendingEmit,
|
|
changeFileSet,
|
|
emitSignatures,
|
|
latestChangedDtsFile
|
|
};
|
|
return createBuildInfo(program, bundle);
|
|
function relativeToBuildInfoEnsuringAbsolutePath(path) {
|
|
return relativeToBuildInfo(getNormalizedAbsolutePath(path, currentDirectory));
|
|
}
|
|
function relativeToBuildInfo(path) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName));
|
|
}
|
|
function toFileId(path) {
|
|
let fileId = fileNameToFileId.get(path);
|
|
if (fileId === void 0) {
|
|
fileNames.push(relativeToBuildInfo(path));
|
|
fileNameToFileId.set(path, fileId = fileNames.length);
|
|
}
|
|
return fileId;
|
|
}
|
|
function toFileIdListId(set) {
|
|
const fileIds = arrayFrom(set.keys(), toFileId).sort(compareValues);
|
|
const key = fileIds.join();
|
|
let fileIdListId = fileNamesToFileIdListId == null ? void 0 : fileNamesToFileIdListId.get(key);
|
|
if (fileIdListId === void 0) {
|
|
(fileIdsList || (fileIdsList = [])).push(fileIds);
|
|
(fileNamesToFileIdListId || (fileNamesToFileIdListId = /* @__PURE__ */ new Map())).set(key, fileIdListId = fileIdsList.length);
|
|
}
|
|
return fileIdListId;
|
|
}
|
|
function convertToProgramBuildInfoCompilerOptions(options) {
|
|
let result;
|
|
const { optionsNameMap } = getOptionsNameMap();
|
|
for (const name of getOwnKeys(options).sort(compareStringsCaseSensitive)) {
|
|
const optionInfo = optionsNameMap.get(name.toLowerCase());
|
|
if (optionInfo == null ? void 0 : optionInfo.affectsBuildInfo) {
|
|
(result || (result = {}))[name] = convertToReusableCompilerOptionValue(
|
|
optionInfo,
|
|
options[name],
|
|
relativeToBuildInfoEnsuringAbsolutePath
|
|
);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
|
|
if (option) {
|
|
if (option.type === "list") {
|
|
const 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) {
|
|
Debug.assert(!!diagnostics.length);
|
|
return diagnostics.map((diagnostic) => {
|
|
const result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
|
|
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
|
|
result.reportDeprecated = diagnostic.reportsDeprecated;
|
|
result.source = diagnostic.source;
|
|
result.skippedOn = diagnostic.skippedOn;
|
|
const { relatedInformation } = diagnostic;
|
|
result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo)) : [] : void 0;
|
|
return result;
|
|
});
|
|
}
|
|
function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
|
|
const { file } = diagnostic;
|
|
return {
|
|
...diagnostic,
|
|
file: file ? relativeToBuildInfo(file.resolvedPath) : void 0
|
|
};
|
|
}
|
|
function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
let host;
|
|
let newProgram;
|
|
let oldProgram;
|
|
if (newProgramOrRootNames === void 0) {
|
|
Debug.assert(hostOrOptions === void 0);
|
|
host = oldProgramOrHost;
|
|
oldProgram = configFileParsingDiagnosticsOrOldProgram;
|
|
Debug.assert(!!oldProgram);
|
|
newProgram = oldProgram.getProgram();
|
|
} else if (isArray(newProgramOrRootNames)) {
|
|
oldProgram = configFileParsingDiagnosticsOrOldProgram;
|
|
newProgram = createProgram({
|
|
rootNames: newProgramOrRootNames,
|
|
options: hostOrOptions,
|
|
host: oldProgramOrHost,
|
|
oldProgram: oldProgram && oldProgram.getProgramOrUndefined(),
|
|
configFileParsingDiagnostics,
|
|
projectReferences
|
|
});
|
|
host = oldProgramOrHost;
|
|
} else {
|
|
newProgram = newProgramOrRootNames;
|
|
host = hostOrOptions;
|
|
oldProgram = oldProgramOrHost;
|
|
configFileParsingDiagnostics = configFileParsingDiagnosticsOrOldProgram;
|
|
}
|
|
return { host, newProgram, oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || emptyArray };
|
|
}
|
|
function getTextHandlingSourceMapForSignature(text, data) {
|
|
return (data == null ? void 0 : data.sourceMapUrlPos) !== void 0 ? text.substring(0, data.sourceMapUrlPos) : text;
|
|
}
|
|
function computeSignatureWithDiagnostics(program, sourceFile, text, host, data) {
|
|
var _a2, _b;
|
|
let getCanonicalFileName;
|
|
text = getTextHandlingSourceMapForSignature(text, data);
|
|
let sourceFileDirectory;
|
|
if ((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length) {
|
|
text += data.diagnostics.map(
|
|
(diagnostic) => `${locationInfo(diagnostic)}${DiagnosticCategory[diagnostic.category]}${diagnostic.code}: ${flattenDiagnosticMessageText2(diagnostic.messageText)}`
|
|
).join("\n");
|
|
}
|
|
return ((_b = host.createHash) != null ? _b : generateDjb2Hash)(text);
|
|
function flattenDiagnosticMessageText2(diagnostic) {
|
|
return isString(diagnostic) ? diagnostic : diagnostic === void 0 ? "" : !diagnostic.next ? diagnostic.messageText : diagnostic.messageText + diagnostic.next.map(flattenDiagnosticMessageText2).join("\n");
|
|
}
|
|
function locationInfo(diagnostic) {
|
|
if (diagnostic.file.resolvedPath === sourceFile.resolvedPath)
|
|
return `(${diagnostic.start},${diagnostic.length})`;
|
|
if (sourceFileDirectory === void 0)
|
|
sourceFileDirectory = getDirectoryPath(sourceFile.resolvedPath);
|
|
return `${ensurePathIsNonModuleName(getRelativePathFromDirectory(
|
|
sourceFileDirectory,
|
|
diagnostic.file.resolvedPath,
|
|
getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames())
|
|
))}(${diagnostic.start},${diagnostic.length})`;
|
|
}
|
|
}
|
|
function computeSignature(text, host, data) {
|
|
var _a2;
|
|
return ((_a2 = host.createHash) != null ? _a2 : generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
|
|
}
|
|
function createBuilderProgram(kind, { newProgram, host, oldProgram, configFileParsingDiagnostics }) {
|
|
let oldState = oldProgram && oldProgram.getState();
|
|
if (oldState && newProgram === oldState.program && configFileParsingDiagnostics === newProgram.getConfigFileParsingDiagnostics()) {
|
|
newProgram = void 0;
|
|
oldState = void 0;
|
|
return oldProgram;
|
|
}
|
|
const state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
|
|
newProgram.getBuildInfo = (bundle) => getBuildInfo2(state, bundle);
|
|
newProgram = void 0;
|
|
oldProgram = void 0;
|
|
oldState = void 0;
|
|
const getState = () => state;
|
|
const builderProgram = createRedirectedBuilderProgram(getState, configFileParsingDiagnostics);
|
|
builderProgram.getState = getState;
|
|
builderProgram.saveEmitState = () => backupBuilderProgramEmitState(state);
|
|
builderProgram.restoreEmitState = (saved) => restoreBuilderProgramEmitState(state, saved);
|
|
builderProgram.hasChangedEmitSignature = () => !!state.hasChangedEmitSignature;
|
|
builderProgram.getAllDependencies = (sourceFile) => BuilderState.getAllDependencies(state, Debug.checkDefined(state.program), sourceFile);
|
|
builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
|
|
builderProgram.emit = emit;
|
|
builderProgram.releaseProgram = () => releaseCache(state);
|
|
if (kind === 0 /* SemanticDiagnosticsBuilderProgram */) {
|
|
builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
|
|
} else if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
|
|
builderProgram.emitNextAffectedFile = emitNextAffectedFile;
|
|
builderProgram.emitBuildInfo = emitBuildInfo;
|
|
} else {
|
|
notImplemented();
|
|
}
|
|
return builderProgram;
|
|
function emitBuildInfo(writeFile2, cancellationToken) {
|
|
if (state.buildInfoEmitPending) {
|
|
const result = Debug.checkDefined(state.program).emitBuildInfo(writeFile2 || maybeBind(host, host.writeFile), cancellationToken);
|
|
state.buildInfoEmitPending = false;
|
|
return result;
|
|
}
|
|
return emitSkippedWithNoDiagnostics;
|
|
}
|
|
function emitNextAffectedFile(writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
var _a2, _b, _c, _d, _e;
|
|
let affected = getNextAffectedFile(state, cancellationToken, host);
|
|
const programEmitKind = getBuilderFileEmit(state.compilerOptions);
|
|
let emitKind = emitOnlyDtsFiles ? programEmitKind & 24 /* AllDts */ : programEmitKind;
|
|
if (!affected) {
|
|
if (!outFile(state.compilerOptions)) {
|
|
const pendingAffectedFile = getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles);
|
|
if (!pendingAffectedFile) {
|
|
if (!state.buildInfoEmitPending)
|
|
return void 0;
|
|
const affected2 = state.program;
|
|
const result2 = affected2.emitBuildInfo(writeFile2 || maybeBind(host, host.writeFile), cancellationToken);
|
|
state.buildInfoEmitPending = false;
|
|
return { result: result2, affected: affected2 };
|
|
}
|
|
({ affectedFile: affected, emitKind } = pendingAffectedFile);
|
|
} else {
|
|
if (!state.programEmitPending)
|
|
return void 0;
|
|
emitKind = state.programEmitPending;
|
|
if (emitOnlyDtsFiles)
|
|
emitKind = emitKind & 24 /* AllDts */;
|
|
if (!emitKind)
|
|
return void 0;
|
|
affected = state.program;
|
|
}
|
|
}
|
|
let emitOnly;
|
|
if (emitKind & 7 /* AllJs */)
|
|
emitOnly = 0 /* Js */;
|
|
if (emitKind & 24 /* AllDts */)
|
|
emitOnly = emitOnly === void 0 ? 1 /* Dts */ : void 0;
|
|
if (affected === state.program) {
|
|
state.programEmitPending = state.changedFilesSet.size ? getPendingEmitKind(programEmitKind, emitKind) : state.programEmitPending ? getPendingEmitKind(state.programEmitPending, emitKind) : void 0;
|
|
}
|
|
const result = state.program.emit(
|
|
affected === state.program ? void 0 : affected,
|
|
getWriteFileCallback(writeFile2, customTransformers),
|
|
cancellationToken,
|
|
emitOnly,
|
|
customTransformers
|
|
);
|
|
if (affected !== state.program) {
|
|
const affectedSourceFile = affected;
|
|
state.seenAffectedFiles.add(affectedSourceFile.resolvedPath);
|
|
if (state.affectedFilesIndex !== void 0)
|
|
state.affectedFilesIndex++;
|
|
state.buildInfoEmitPending = true;
|
|
const existing = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedSourceFile.resolvedPath)) || 0 /* None */;
|
|
((_b = state.seenEmittedFiles) != null ? _b : state.seenEmittedFiles = /* @__PURE__ */ new Map()).set(affectedSourceFile.resolvedPath, emitKind | existing);
|
|
const existingPending = ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.get(affectedSourceFile.resolvedPath)) || programEmitKind;
|
|
const pendingKind = getPendingEmitKind(existingPending, emitKind | existing);
|
|
if (pendingKind)
|
|
((_d = state.affectedFilesPendingEmit) != null ? _d : state.affectedFilesPendingEmit = /* @__PURE__ */ new Map()).set(affectedSourceFile.resolvedPath, pendingKind);
|
|
else
|
|
(_e = state.affectedFilesPendingEmit) == null ? void 0 : _e.delete(affectedSourceFile.resolvedPath);
|
|
} else {
|
|
state.changedFilesSet.clear();
|
|
}
|
|
return { result, affected };
|
|
}
|
|
function getWriteFileCallback(writeFile2, customTransformers) {
|
|
if (!getEmitDeclarations(state.compilerOptions))
|
|
return writeFile2 || maybeBind(host, host.writeFile);
|
|
return (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
|
|
var _a2, _b, _c, _d, _e, _f, _g;
|
|
if (isDeclarationFileName(fileName)) {
|
|
if (!outFile(state.compilerOptions)) {
|
|
Debug.assert((sourceFiles == null ? void 0 : sourceFiles.length) === 1);
|
|
let emitSignature;
|
|
if (!customTransformers) {
|
|
const file = sourceFiles[0];
|
|
const info = state.fileInfos.get(file.resolvedPath);
|
|
if (info.signature === file.version) {
|
|
const signature = computeSignatureWithDiagnostics(
|
|
state.program,
|
|
file,
|
|
text,
|
|
host,
|
|
data
|
|
);
|
|
if (!((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length))
|
|
emitSignature = signature;
|
|
if (signature !== file.version) {
|
|
if (host.storeFilesChangingSignatureDuringEmit)
|
|
((_b = state.filesChangingSignature) != null ? _b : state.filesChangingSignature = /* @__PURE__ */ new Set()).add(file.resolvedPath);
|
|
if (state.exportedModulesMap)
|
|
BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
|
|
if (state.affectedFiles) {
|
|
const existing = (_c = state.oldSignatures) == null ? void 0 : _c.get(file.resolvedPath);
|
|
if (existing === void 0)
|
|
((_d = state.oldSignatures) != null ? _d : state.oldSignatures = /* @__PURE__ */ new Map()).set(file.resolvedPath, info.signature || false);
|
|
info.signature = signature;
|
|
} else {
|
|
info.signature = signature;
|
|
(_e = state.oldExportedModulesMap) == null ? void 0 : _e.clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state.compilerOptions.composite) {
|
|
const filePath = sourceFiles[0].resolvedPath;
|
|
emitSignature = handleNewSignature((_f = state.emitSignatures) == null ? void 0 : _f.get(filePath), emitSignature);
|
|
if (!emitSignature)
|
|
return;
|
|
((_g = state.emitSignatures) != null ? _g : state.emitSignatures = /* @__PURE__ */ new Map()).set(filePath, emitSignature);
|
|
}
|
|
} else if (state.compilerOptions.composite) {
|
|
const newSignature = handleNewSignature(state.outSignature, void 0);
|
|
if (!newSignature)
|
|
return;
|
|
state.outSignature = newSignature;
|
|
}
|
|
}
|
|
if (writeFile2)
|
|
writeFile2(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);
|
|
function handleNewSignature(oldSignatureFormat, newSignature) {
|
|
const oldSignature = !oldSignatureFormat || isString(oldSignatureFormat) ? oldSignatureFormat : oldSignatureFormat[0];
|
|
newSignature != null ? newSignature : newSignature = computeSignature(text, host, data);
|
|
if (newSignature === oldSignature) {
|
|
if (oldSignatureFormat === oldSignature)
|
|
return void 0;
|
|
else if (data)
|
|
data.differsOnlyInMap = true;
|
|
else
|
|
data = { differsOnlyInMap: true };
|
|
} else {
|
|
state.hasChangedEmitSignature = true;
|
|
state.latestChangedDtsFile = fileName;
|
|
}
|
|
return newSignature;
|
|
}
|
|
};
|
|
}
|
|
function emit(targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile);
|
|
}
|
|
const result = handleNoEmitOptions(builderProgram, targetSourceFile, writeFile2, cancellationToken);
|
|
if (result)
|
|
return result;
|
|
if (!targetSourceFile) {
|
|
if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
let sourceMaps = [];
|
|
let emitSkipped = false;
|
|
let diagnostics;
|
|
let emittedFiles = [];
|
|
let affectedEmitResult;
|
|
while (affectedEmitResult = emitNextAffectedFile(writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
|
|
emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
|
|
diagnostics = addRange(diagnostics, affectedEmitResult.result.diagnostics);
|
|
emittedFiles = addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
|
|
sourceMaps = addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
|
|
}
|
|
return {
|
|
emitSkipped,
|
|
diagnostics: diagnostics || emptyArray,
|
|
emittedFiles,
|
|
sourceMaps
|
|
};
|
|
} else {
|
|
clearAffectedFilesPendingEmit(state, emitOnlyDtsFiles);
|
|
}
|
|
}
|
|
return Debug.checkDefined(state.program).emit(
|
|
targetSourceFile,
|
|
getWriteFileCallback(writeFile2, customTransformers),
|
|
cancellationToken,
|
|
emitOnlyDtsFiles,
|
|
customTransformers
|
|
);
|
|
}
|
|
function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
|
|
while (true) {
|
|
const affected = getNextAffectedFile(state, cancellationToken, host);
|
|
let result;
|
|
if (!affected)
|
|
return void 0;
|
|
else if (affected !== state.program) {
|
|
const affectedSourceFile = affected;
|
|
if (!ignoreSourceFile || !ignoreSourceFile(affectedSourceFile)) {
|
|
result = getSemanticDiagnosticsOfFile(state, affectedSourceFile, cancellationToken);
|
|
}
|
|
state.seenAffectedFiles.add(affectedSourceFile.resolvedPath);
|
|
state.affectedFilesIndex++;
|
|
state.buildInfoEmitPending = true;
|
|
if (!result)
|
|
continue;
|
|
} else {
|
|
result = state.program.getSemanticDiagnostics(void 0, cancellationToken);
|
|
state.changedFilesSet.clear();
|
|
state.programEmitPending = getBuilderFileEmit(state.compilerOptions);
|
|
}
|
|
return { result, affected };
|
|
}
|
|
}
|
|
function getSemanticDiagnostics(sourceFile, cancellationToken) {
|
|
assertSourceFileOkWithoutNextAffectedCall(state, sourceFile);
|
|
const compilerOptions = Debug.checkDefined(state.program).getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
Debug.assert(!state.semanticDiagnosticsPerFile);
|
|
return Debug.checkDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
}
|
|
if (sourceFile) {
|
|
return getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken);
|
|
}
|
|
while (getSemanticDiagnosticsOfNextAffectedFile(cancellationToken)) {
|
|
}
|
|
let diagnostics;
|
|
for (const sourceFile2 of Debug.checkDefined(state.program).getSourceFiles()) {
|
|
diagnostics = addRange(diagnostics, getSemanticDiagnosticsOfFile(state, sourceFile2, cancellationToken));
|
|
}
|
|
return diagnostics || emptyArray;
|
|
}
|
|
}
|
|
function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) {
|
|
var _a2, _b;
|
|
const existingKind = ((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.get(affectedFilePendingEmit)) || 0 /* None */;
|
|
((_b = state.affectedFilesPendingEmit) != null ? _b : state.affectedFilesPendingEmit = /* @__PURE__ */ new Map()).set(affectedFilePendingEmit, existingKind | kind);
|
|
}
|
|
function toBuilderStateFileInfoForMultiEmit(fileInfo) {
|
|
return isString(fileInfo) ? { version: fileInfo, signature: fileInfo, affectsGlobalScope: void 0, impliedFormat: void 0 } : isString(fileInfo.signature) ? fileInfo : { version: fileInfo.version, signature: fileInfo.signature === false ? void 0 : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
|
|
}
|
|
function toBuilderFileEmit(value, fullEmitForOptions) {
|
|
return isNumber(value) ? fullEmitForOptions : value[1] || 8 /* Dts */;
|
|
}
|
|
function toProgramEmitPending(value, options) {
|
|
return !value ? getBuilderFileEmit(options || {}) : value;
|
|
}
|
|
function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, host) {
|
|
var _a2, _b, _c, _d;
|
|
const program = buildInfo.program;
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
let state;
|
|
const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPath3);
|
|
let filePathsSetList;
|
|
const latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : void 0;
|
|
if (isProgramBundleEmitBuildInfo(program)) {
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toFilePath(index + 1);
|
|
fileInfos.set(path, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
|
|
});
|
|
state = {
|
|
fileInfos,
|
|
compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
|
|
latestChangedDtsFile,
|
|
outSignature: program.outSignature,
|
|
programEmitPending: program.pendingEmit === void 0 ? void 0 : toProgramEmitPending(program.pendingEmit, program.options),
|
|
bundle: buildInfo.bundle
|
|
};
|
|
} else {
|
|
filePathsSetList = (_b = program.fileIdsList) == null ? void 0 : _b.map((fileIds) => new Set(fileIds.map(toFilePath)));
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
const emitSignatures = ((_c = program.options) == null ? void 0 : _c.composite) && !outFile(program.options) ? /* @__PURE__ */ new Map() : void 0;
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toFilePath(index + 1);
|
|
const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
|
|
fileInfos.set(path, stateFileInfo);
|
|
if (emitSignatures && stateFileInfo.signature)
|
|
emitSignatures.set(path, stateFileInfo.signature);
|
|
});
|
|
(_d = program.emitSignatures) == null ? void 0 : _d.forEach((value) => {
|
|
if (isNumber(value))
|
|
emitSignatures.delete(toFilePath(value));
|
|
else {
|
|
const key = toFilePath(value[0]);
|
|
emitSignatures.set(
|
|
key,
|
|
!isString(value[1]) && !value[1].length ? [emitSignatures.get(key)] : value[1]
|
|
);
|
|
}
|
|
});
|
|
const fullEmitForOptions = program.affectedFilesPendingEmit ? getBuilderFileEmit(program.options || {}) : void 0;
|
|
state = {
|
|
fileInfos,
|
|
compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
|
|
referencedMap: toManyToManyPathMap(program.referencedMap),
|
|
exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
|
|
semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && arrayToMap(program.semanticDiagnosticsPerFile, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]),
|
|
hasReusableDiagnostic: true,
|
|
affectedFilesPendingEmit: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => toBuilderFileEmit(value, fullEmitForOptions)),
|
|
changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
|
|
latestChangedDtsFile,
|
|
emitSignatures: (emitSignatures == null ? void 0 : emitSignatures.size) ? emitSignatures : void 0
|
|
};
|
|
}
|
|
return {
|
|
getState: () => state,
|
|
saveEmitState: noop,
|
|
restoreEmitState: noop,
|
|
getProgram: notImplemented,
|
|
getProgramOrUndefined: returnUndefined,
|
|
releaseProgram: noop,
|
|
getCompilerOptions: () => state.compilerOptions,
|
|
getSourceFile: notImplemented,
|
|
getSourceFiles: notImplemented,
|
|
getOptionsDiagnostics: notImplemented,
|
|
getGlobalDiagnostics: notImplemented,
|
|
getConfigFileParsingDiagnostics: notImplemented,
|
|
getSyntacticDiagnostics: notImplemented,
|
|
getDeclarationDiagnostics: notImplemented,
|
|
getSemanticDiagnostics: notImplemented,
|
|
emit: notImplemented,
|
|
getAllDependencies: notImplemented,
|
|
getCurrentDirectory: notImplemented,
|
|
emitNextAffectedFile: notImplemented,
|
|
getSemanticDiagnosticsOfNextAffectedFile: notImplemented,
|
|
emitBuildInfo: notImplemented,
|
|
close: noop,
|
|
hasChangedEmitSignature: returnFalse
|
|
};
|
|
function toPath3(path) {
|
|
return toPath(path, buildInfoDirectory, getCanonicalFileName);
|
|
}
|
|
function toAbsolutePath(path) {
|
|
return getNormalizedAbsolutePath(path, buildInfoDirectory);
|
|
}
|
|
function toFilePath(fileId) {
|
|
return filePaths[fileId - 1];
|
|
}
|
|
function toFilePathsSet(fileIdsListId) {
|
|
return filePathsSetList[fileIdsListId - 1];
|
|
}
|
|
function toManyToManyPathMap(referenceMap) {
|
|
if (!referenceMap) {
|
|
return void 0;
|
|
}
|
|
const map2 = BuilderState.createManyToManyPathMap();
|
|
referenceMap.forEach(
|
|
([fileId, fileIdListId]) => map2.set(toFilePath(fileId), toFilePathsSet(fileIdListId))
|
|
);
|
|
return map2;
|
|
}
|
|
}
|
|
function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
|
|
const version2 = isString(fileInfo) ? fileInfo : fileInfo.version;
|
|
fileInfos.set(path, version2);
|
|
});
|
|
return fileInfos;
|
|
}
|
|
function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) {
|
|
return {
|
|
getState: notImplemented,
|
|
saveEmitState: noop,
|
|
restoreEmitState: noop,
|
|
getProgram,
|
|
getProgramOrUndefined: () => getState().program,
|
|
releaseProgram: () => getState().program = void 0,
|
|
getCompilerOptions: () => getState().compilerOptions,
|
|
getSourceFile: (fileName) => getProgram().getSourceFile(fileName),
|
|
getSourceFiles: () => getProgram().getSourceFiles(),
|
|
getOptionsDiagnostics: (cancellationToken) => getProgram().getOptionsDiagnostics(cancellationToken),
|
|
getGlobalDiagnostics: (cancellationToken) => getProgram().getGlobalDiagnostics(cancellationToken),
|
|
getConfigFileParsingDiagnostics: () => configFileParsingDiagnostics,
|
|
getSyntacticDiagnostics: (sourceFile, cancellationToken) => getProgram().getSyntacticDiagnostics(sourceFile, cancellationToken),
|
|
getDeclarationDiagnostics: (sourceFile, cancellationToken) => getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken),
|
|
getSemanticDiagnostics: (sourceFile, cancellationToken) => getProgram().getSemanticDiagnostics(sourceFile, cancellationToken),
|
|
emit: (sourceFile, writeFile2, cancellationToken, emitOnlyDts, customTransformers) => getProgram().emit(sourceFile, writeFile2, cancellationToken, emitOnlyDts, customTransformers),
|
|
emitBuildInfo: (writeFile2, cancellationToken) => getProgram().emitBuildInfo(writeFile2, cancellationToken),
|
|
getAllDependencies: notImplemented,
|
|
getCurrentDirectory: () => getProgram().getCurrentDirectory(),
|
|
close: noop
|
|
};
|
|
function getProgram() {
|
|
return Debug.checkDefined(getState().program);
|
|
}
|
|
}
|
|
|
|
// src/compiler/builderPublic.ts
|
|
function createEmitAndSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
return createBuilderProgram(1 /* EmitAndSemanticDiagnosticsBuilderProgram */, getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences));
|
|
}
|
|
|
|
// src/compiler/resolutionCache.ts
|
|
function removeIgnoredPath(path) {
|
|
if (endsWith(path, "/node_modules/.staging")) {
|
|
return removeSuffix(path, "/.staging");
|
|
}
|
|
return some(ignoredPaths, (searchPath) => stringContains(path, searchPath)) ? void 0 : path;
|
|
}
|
|
function canWatchDirectoryOrFile(dirPath) {
|
|
const rootLength = getRootLength(dirPath);
|
|
if (dirPath.length === rootLength) {
|
|
return false;
|
|
}
|
|
let nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
|
|
if (nextDirectorySeparator === -1) {
|
|
return false;
|
|
}
|
|
let pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1);
|
|
const isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* slash */;
|
|
if (isNonDirectorySeparatorRoot && dirPath.search(/[a-zA-Z]:/) !== 0 && pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) {
|
|
nextDirectorySeparator = dirPath.indexOf(directorySeparator, nextDirectorySeparator + 1);
|
|
if (nextDirectorySeparator === -1) {
|
|
return false;
|
|
}
|
|
pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1);
|
|
}
|
|
if (isNonDirectorySeparatorRoot && pathPartForUserCheck.search(/users\//i) !== 0) {
|
|
return true;
|
|
}
|
|
for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
|
|
searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
|
|
if (searchIndex === 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
|
|
let filesWithChangedSetOfUnresolvedImports;
|
|
let filesWithInvalidatedResolutions;
|
|
let filesWithInvalidatedNonRelativeUnresolvedImports;
|
|
const nonRelativeExternalModuleResolutions = createMultiMap();
|
|
const resolutionsWithFailedLookups = [];
|
|
const resolutionsWithOnlyAffectingLocations = [];
|
|
const resolvedFileToResolution = createMultiMap();
|
|
const impliedFormatPackageJsons = /* @__PURE__ */ new Map();
|
|
let hasChangedAutomaticTypeDirectiveNames = false;
|
|
let affectingPathChecksForFile;
|
|
let affectingPathChecks;
|
|
let failedLookupChecks;
|
|
let startsWithPathChecks;
|
|
let isInDirectoryChecks;
|
|
const getCurrentDirectory = memoize(() => resolutionHost.getCurrentDirectory());
|
|
const cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
|
|
const resolvedModuleNames = /* @__PURE__ */ new Map();
|
|
const perDirectoryResolvedModuleNames = createCacheWithRedirects();
|
|
const nonRelativeModuleNameCache = createCacheWithRedirects();
|
|
const moduleResolutionCache = createModuleResolutionCache(
|
|
getCurrentDirectory(),
|
|
resolutionHost.getCanonicalFileName,
|
|
void 0,
|
|
perDirectoryResolvedModuleNames,
|
|
nonRelativeModuleNameCache
|
|
);
|
|
const resolvedTypeReferenceDirectives = /* @__PURE__ */ new Map();
|
|
const perDirectoryResolvedTypeReferenceDirectives = createCacheWithRedirects();
|
|
const typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(
|
|
getCurrentDirectory(),
|
|
resolutionHost.getCanonicalFileName,
|
|
void 0,
|
|
moduleResolutionCache.getPackageJsonInfoCache(),
|
|
perDirectoryResolvedTypeReferenceDirectives
|
|
);
|
|
const failedLookupDefaultExtensions = [".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */, ".json" /* Json */];
|
|
const customFailedLookupPaths = /* @__PURE__ */ new Map();
|
|
const directoryWatchesOfFailedLookups = /* @__PURE__ */ new Map();
|
|
const fileWatchesOfAffectingLocations = /* @__PURE__ */ new Map();
|
|
const rootDir = rootDirForResolution && removeTrailingDirectorySeparator(getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
|
|
const rootPath = rootDir && resolutionHost.toPath(rootDir);
|
|
const rootSplitLength = rootPath !== void 0 ? rootPath.split(directorySeparator).length : 0;
|
|
const typeRootsWatches = /* @__PURE__ */ new Map();
|
|
return {
|
|
getModuleResolutionCache: () => moduleResolutionCache,
|
|
startRecordingFilesWithChangedResolutions,
|
|
finishRecordingFilesWithChangedResolutions,
|
|
startCachingPerDirectoryResolution,
|
|
finishCachingPerDirectoryResolution,
|
|
resolveModuleNames,
|
|
getResolvedModuleWithFailedLookupLocationsFromCache,
|
|
resolveTypeReferenceDirectives,
|
|
removeResolutionsFromProjectReferenceRedirects,
|
|
removeResolutionsOfFile,
|
|
hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,
|
|
invalidateResolutionOfFile,
|
|
invalidateResolutionsOfFailedLookupLocations,
|
|
setFilesWithInvalidatedNonRelativeUnresolvedImports,
|
|
createHasInvalidatedResolutions,
|
|
isFileWithInvalidatedNonRelativeUnresolvedImports,
|
|
updateTypeRootsWatch,
|
|
closeTypeRootsWatch,
|
|
clear: clear2
|
|
};
|
|
function getResolvedModule2(resolution) {
|
|
return resolution.resolvedModule;
|
|
}
|
|
function getResolvedTypeReferenceDirective2(resolution) {
|
|
return resolution.resolvedTypeReferenceDirective;
|
|
}
|
|
function isInDirectoryPath(dir, file) {
|
|
if (dir === void 0 || file.length <= dir.length) {
|
|
return false;
|
|
}
|
|
return startsWith(file, dir) && file[dir.length] === directorySeparator;
|
|
}
|
|
function clear2() {
|
|
clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
|
|
clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
|
|
customFailedLookupPaths.clear();
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
closeTypeRootsWatch();
|
|
resolvedModuleNames.clear();
|
|
resolvedTypeReferenceDirectives.clear();
|
|
resolvedFileToResolution.clear();
|
|
resolutionsWithFailedLookups.length = 0;
|
|
resolutionsWithOnlyAffectingLocations.length = 0;
|
|
failedLookupChecks = void 0;
|
|
startsWithPathChecks = void 0;
|
|
isInDirectoryChecks = void 0;
|
|
affectingPathChecks = void 0;
|
|
affectingPathChecksForFile = void 0;
|
|
moduleResolutionCache.clear();
|
|
typeReferenceDirectiveResolutionCache.clear();
|
|
impliedFormatPackageJsons.clear();
|
|
hasChangedAutomaticTypeDirectiveNames = false;
|
|
}
|
|
function startRecordingFilesWithChangedResolutions() {
|
|
filesWithChangedSetOfUnresolvedImports = [];
|
|
}
|
|
function finishRecordingFilesWithChangedResolutions() {
|
|
const collected = filesWithChangedSetOfUnresolvedImports;
|
|
filesWithChangedSetOfUnresolvedImports = void 0;
|
|
return collected;
|
|
}
|
|
function isFileWithInvalidatedNonRelativeUnresolvedImports(path) {
|
|
if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
|
|
return false;
|
|
}
|
|
const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
|
|
return !!value && !!value.length;
|
|
}
|
|
function createHasInvalidatedResolutions(customHasInvalidatedResolutions) {
|
|
invalidateResolutionsOfFailedLookupLocations();
|
|
const collected = filesWithInvalidatedResolutions;
|
|
filesWithInvalidatedResolutions = void 0;
|
|
return (path) => customHasInvalidatedResolutions(path) || !!(collected == null ? void 0 : collected.has(path)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path);
|
|
}
|
|
function startCachingPerDirectoryResolution() {
|
|
moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
|
|
typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
|
|
nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
}
|
|
function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
|
|
filesWithInvalidatedNonRelativeUnresolvedImports = void 0;
|
|
nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
if (newProgram !== oldProgram) {
|
|
newProgram == null ? void 0 : newProgram.getSourceFiles().forEach((newFile) => {
|
|
var _a2, _b, _c;
|
|
const expected = isExternalOrCommonJsModule(newFile) ? (_b = (_a2 = newFile.packageJsonLocations) == null ? void 0 : _a2.length) != null ? _b : 0 : 0;
|
|
const existing = (_c = impliedFormatPackageJsons.get(newFile.path)) != null ? _c : emptyArray;
|
|
for (let i = existing.length; i < expected; i++) {
|
|
createFileWatcherOfAffectingLocation(newFile.packageJsonLocations[i], false);
|
|
}
|
|
if (existing.length > expected) {
|
|
for (let 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((existing, path) => {
|
|
if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
|
|
existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
|
|
impliedFormatPackageJsons.delete(path);
|
|
}
|
|
});
|
|
}
|
|
directoryWatchesOfFailedLookups.forEach((watcher, path) => {
|
|
if (watcher.refCount === 0) {
|
|
directoryWatchesOfFailedLookups.delete(path);
|
|
watcher.watcher.close();
|
|
}
|
|
});
|
|
fileWatchesOfAffectingLocations.forEach((watcher, path) => {
|
|
if (watcher.files === 0 && watcher.resolutions === 0) {
|
|
fileWatchesOfAffectingLocations.delete(path);
|
|
watcher.watcher.close();
|
|
}
|
|
});
|
|
hasChangedAutomaticTypeDirectiveNames = false;
|
|
}
|
|
function resolveModuleName2(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
|
|
const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
|
|
if (!resolutionHost.getGlobalCache) {
|
|
return primaryResult;
|
|
}
|
|
const globalCache = resolutionHost.getGlobalCache();
|
|
if (globalCache !== void 0 && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {
|
|
const { resolvedModule, failedLookupLocations, affectingLocations } = loadModuleFromGlobalCache(
|
|
Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName),
|
|
resolutionHost.projectName,
|
|
compilerOptions,
|
|
host,
|
|
globalCache,
|
|
moduleResolutionCache
|
|
);
|
|
if (resolvedModule) {
|
|
primaryResult.resolvedModule = resolvedModule;
|
|
primaryResult.failedLookupLocations.push(...failedLookupLocations);
|
|
primaryResult.affectingLocations.push(...affectingLocations);
|
|
return primaryResult;
|
|
}
|
|
}
|
|
return primaryResult;
|
|
}
|
|
function resolveTypeReferenceDirective2(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) {
|
|
return resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
|
|
}
|
|
function resolveNamesWithLocalCache({
|
|
names,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache,
|
|
perDirectoryCacheWithRedirects,
|
|
loader,
|
|
getResolutionWithResolvedFileName,
|
|
shouldRetryResolution,
|
|
reusedNames,
|
|
resolutionInfo,
|
|
logChanges,
|
|
containingSourceFile,
|
|
containingSourceFileMode
|
|
}) {
|
|
var _a2, _b, _c, _d;
|
|
const path = resolutionHost.toPath(containingFile);
|
|
const resolutionsInFile = cache.get(path) || cache.set(path, createModeAwareCache()).get(path);
|
|
const dirPath = getDirectoryPath(path);
|
|
const perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
|
|
let perDirectoryResolution = perDirectoryCache.get(dirPath);
|
|
if (!perDirectoryResolution) {
|
|
perDirectoryResolution = createModeAwareCache();
|
|
perDirectoryCache.set(dirPath, perDirectoryResolution);
|
|
}
|
|
const resolvedModules = [];
|
|
const compilerOptions = resolutionHost.getCompilationSettings();
|
|
const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
|
|
const program = resolutionHost.getCurrentProgram();
|
|
const oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile);
|
|
const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
|
|
const seenNamesInFile = createModeAwareCache();
|
|
let i = 0;
|
|
for (const entry of containingSourceFile && resolutionInfo ? resolutionInfo.names : names) {
|
|
const name = getResolutionName(entry);
|
|
const mode = !isString(entry) ? isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode) : containingSourceFile ? getModeForResolutionAtIndex(containingSourceFile, i) : void 0;
|
|
i++;
|
|
let resolution = resolutionsInFile.get(name, mode);
|
|
if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
|
|
const existingResolution = resolution;
|
|
const resolutionInDirectory = perDirectoryResolution.get(name, mode);
|
|
if (resolutionInDirectory) {
|
|
resolution = resolutionInDirectory;
|
|
const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
|
|
if (isTraceEnabled(compilerOptions, host)) {
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
trace(
|
|
host,
|
|
loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 : Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? 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 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved,
|
|
name,
|
|
containingFile,
|
|
getDirectoryPath(containingFile),
|
|
resolved == null ? void 0 : resolved.resolvedFileName,
|
|
(resolved == null ? void 0 : resolved.packageId) && packageIdToString(resolved.packageId)
|
|
);
|
|
}
|
|
} else {
|
|
resolution = loader(name, containingFile, compilerOptions, ((_b = resolutionHost.getCompilerHost) == null ? void 0 : _b.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);
|
|
logChanges = false;
|
|
}
|
|
} else {
|
|
const host = ((_c = resolutionHost.getCompilerHost) == null ? void 0 : _c.call(resolutionHost)) || resolutionHost;
|
|
if (isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) {
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
trace(
|
|
host,
|
|
loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
|
|
name,
|
|
containingFile,
|
|
resolved == null ? void 0 : resolved.resolvedFileName,
|
|
(resolved == null ? void 0 : resolved.packageId) && packageIdToString(resolved.packageId)
|
|
);
|
|
}
|
|
}
|
|
Debug.assert(resolution !== void 0 && !resolution.isInvalidated);
|
|
seenNamesInFile.set(name, mode, true);
|
|
resolvedModules.push(getResolutionWithResolvedFileName(resolution));
|
|
}
|
|
if (resolutionInfo && (loader === resolveTypeReferenceDirective2 || containingSourceFile)) {
|
|
(_d = resolutionInfo.reusedNames) == null ? void 0 : _d.forEach((entry) => seenNamesInFile.set(
|
|
getResolutionName(entry),
|
|
!isString(entry) && isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode),
|
|
true
|
|
));
|
|
reusedNames = void 0;
|
|
}
|
|
if (resolutionsInFile.size() !== seenNamesInFile.size()) {
|
|
resolutionsInFile.forEach((resolution, name, mode) => {
|
|
if (!seenNamesInFile.has(name, mode) && !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;
|
|
}
|
|
const oldResult = getResolutionWithResolvedFileName(oldResolution);
|
|
const newResult = getResolutionWithResolvedFileName(newResolution);
|
|
if (oldResult === newResult) {
|
|
return true;
|
|
}
|
|
if (!oldResult || !newResult) {
|
|
return false;
|
|
}
|
|
return oldResult.resolvedFileName === newResult.resolvedFileName;
|
|
}
|
|
}
|
|
function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) {
|
|
return resolveNamesWithLocalCache({
|
|
names: typeDirectiveNames,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache: resolvedTypeReferenceDirectives,
|
|
perDirectoryCacheWithRedirects: perDirectoryResolvedTypeReferenceDirectives,
|
|
loader: resolveTypeReferenceDirective2,
|
|
getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective2,
|
|
shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
|
|
containingSourceFileMode: containingFileMode,
|
|
resolutionInfo
|
|
});
|
|
}
|
|
function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo) {
|
|
return resolveNamesWithLocalCache({
|
|
names: moduleNames,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache: resolvedModuleNames,
|
|
perDirectoryCacheWithRedirects: perDirectoryResolvedModuleNames,
|
|
loader: resolveModuleName2,
|
|
getResolutionWithResolvedFileName: getResolvedModule2,
|
|
shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
|
|
reusedNames,
|
|
resolutionInfo,
|
|
logChanges: logChangesWhenResolvingModule,
|
|
containingSourceFile
|
|
});
|
|
}
|
|
function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
|
|
const cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
|
|
if (!cache)
|
|
return void 0;
|
|
return cache.get(moduleName, resolutionMode);
|
|
}
|
|
function isNodeModulesAtTypesDirectory(dirPath) {
|
|
return endsWith(dirPath, "/node_modules/@types");
|
|
}
|
|
function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath) {
|
|
if (isInDirectoryPath(rootPath, failedLookupLocationPath)) {
|
|
failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
|
|
const failedLookupPathSplit = failedLookupLocationPath.split(directorySeparator);
|
|
const failedLookupSplit = failedLookupLocation.split(directorySeparator);
|
|
Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, `FailedLookup: ${failedLookupLocation} failedLookupLocationPath: ${failedLookupLocationPath}`);
|
|
if (failedLookupPathSplit.length > rootSplitLength + 1) {
|
|
return {
|
|
dir: failedLookupSplit.slice(0, rootSplitLength + 1).join(directorySeparator),
|
|
dirPath: failedLookupPathSplit.slice(0, rootSplitLength + 1).join(directorySeparator)
|
|
};
|
|
} else {
|
|
return {
|
|
dir: rootDir,
|
|
dirPath: rootPath,
|
|
nonRecursive: false
|
|
};
|
|
}
|
|
}
|
|
return getDirectoryToWatchFromFailedLookupLocationDirectory(
|
|
getDirectoryPath(getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())),
|
|
getDirectoryPath(failedLookupLocationPath)
|
|
);
|
|
}
|
|
function getDirectoryToWatchFromFailedLookupLocationDirectory(dir, dirPath) {
|
|
while (pathContainsNodeModules(dirPath)) {
|
|
dir = getDirectoryPath(dir);
|
|
dirPath = getDirectoryPath(dirPath);
|
|
}
|
|
if (isNodeModulesDirectory(dirPath)) {
|
|
return canWatchDirectoryOrFile(getDirectoryPath(dirPath)) ? { dir, dirPath } : void 0;
|
|
}
|
|
let nonRecursive = true;
|
|
let subDirectoryPath, subDirectory;
|
|
if (rootPath !== void 0) {
|
|
while (!isInDirectoryPath(dirPath, rootPath)) {
|
|
const parentPath = getDirectoryPath(dirPath);
|
|
if (parentPath === dirPath) {
|
|
break;
|
|
}
|
|
nonRecursive = false;
|
|
subDirectoryPath = dirPath;
|
|
subDirectory = dir;
|
|
dirPath = parentPath;
|
|
dir = getDirectoryPath(dir);
|
|
}
|
|
}
|
|
return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive } : void 0;
|
|
}
|
|
function isPathWithDefaultFailedLookupExtension(path) {
|
|
return fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
|
|
}
|
|
function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
|
|
if (resolution.refCount) {
|
|
resolution.refCount++;
|
|
Debug.assertIsDefined(resolution.files);
|
|
} else {
|
|
resolution.refCount = 1;
|
|
Debug.assert(length(resolution.files) === 0);
|
|
if (isExternalModuleNameRelative(name)) {
|
|
watchFailedLookupLocationOfResolution(resolution);
|
|
} else {
|
|
nonRelativeExternalModuleResolutions.add(name, resolution);
|
|
}
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
if (resolved && resolved.resolvedFileName) {
|
|
resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution);
|
|
}
|
|
}
|
|
(resolution.files || (resolution.files = [])).push(filePath);
|
|
}
|
|
function watchFailedLookupLocationOfResolution(resolution) {
|
|
Debug.assert(!!resolution.refCount);
|
|
const { failedLookupLocations, affectingLocations } = resolution;
|
|
if (!failedLookupLocations.length && !affectingLocations.length)
|
|
return;
|
|
if (failedLookupLocations.length)
|
|
resolutionsWithFailedLookups.push(resolution);
|
|
let setAtRoot = false;
|
|
for (const failedLookupLocation of failedLookupLocations) {
|
|
const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
|
|
const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
|
|
if (toWatch) {
|
|
const { dir, dirPath, nonRecursive } = toWatch;
|
|
if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
|
|
const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
|
|
customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
|
|
}
|
|
if (dirPath === rootPath) {
|
|
Debug.assert(!nonRecursive);
|
|
setAtRoot = true;
|
|
} else {
|
|
setDirectoryWatcher(dir, dirPath, nonRecursive);
|
|
}
|
|
}
|
|
}
|
|
if (setAtRoot) {
|
|
setDirectoryWatcher(rootDir, rootPath, true);
|
|
}
|
|
watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
|
|
}
|
|
function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
|
|
Debug.assert(!!resolution.refCount);
|
|
const { affectingLocations } = resolution;
|
|
if (!affectingLocations.length)
|
|
return;
|
|
if (addToResolutionsWithOnlyAffectingLocations)
|
|
resolutionsWithOnlyAffectingLocations.push(resolution);
|
|
for (const affectingLocation of affectingLocations) {
|
|
createFileWatcherOfAffectingLocation(affectingLocation, true);
|
|
}
|
|
}
|
|
function createFileWatcherOfAffectingLocation(affectingLocation, forResolution) {
|
|
const fileWatcher = fileWatchesOfAffectingLocations.get(affectingLocation);
|
|
if (fileWatcher) {
|
|
if (forResolution)
|
|
fileWatcher.resolutions++;
|
|
else
|
|
fileWatcher.files++;
|
|
return;
|
|
}
|
|
let locationToWatch = affectingLocation;
|
|
if (resolutionHost.realpath) {
|
|
locationToWatch = resolutionHost.realpath(affectingLocation);
|
|
if (affectingLocation !== locationToWatch) {
|
|
const fileWatcher2 = fileWatchesOfAffectingLocations.get(locationToWatch);
|
|
if (fileWatcher2) {
|
|
if (forResolution)
|
|
fileWatcher2.resolutions++;
|
|
else
|
|
fileWatcher2.files++;
|
|
fileWatcher2.paths.add(affectingLocation);
|
|
fileWatchesOfAffectingLocations.set(affectingLocation, fileWatcher2);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
const paths = /* @__PURE__ */ new Set();
|
|
paths.add(locationToWatch);
|
|
let actualWatcher = canWatchDirectoryOrFile(resolutionHost.toPath(locationToWatch)) ? resolutionHost.watchAffectingFileLocation(locationToWatch, (fileName, eventKind) => {
|
|
cachedDirectoryStructureHost == null ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind);
|
|
const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
|
|
paths.forEach((path) => {
|
|
if (watcher.resolutions)
|
|
(affectingPathChecks != null ? affectingPathChecks : affectingPathChecks = /* @__PURE__ */ new Set()).add(path);
|
|
if (watcher.files)
|
|
(affectingPathChecksForFile != null ? affectingPathChecksForFile : affectingPathChecksForFile = /* @__PURE__ */ new Set()).add(path);
|
|
packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path));
|
|
});
|
|
resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
|
|
}) : noopFileWatcher;
|
|
const watcher = {
|
|
watcher: actualWatcher !== noopFileWatcher ? {
|
|
close: () => {
|
|
actualWatcher.close();
|
|
actualWatcher = noopFileWatcher;
|
|
}
|
|
} : actualWatcher,
|
|
resolutions: forResolution ? 1 : 0,
|
|
files: forResolution ? 0 : 1,
|
|
paths
|
|
};
|
|
fileWatchesOfAffectingLocations.set(locationToWatch, watcher);
|
|
if (affectingLocation !== locationToWatch) {
|
|
fileWatchesOfAffectingLocations.set(affectingLocation, watcher);
|
|
paths.add(affectingLocation);
|
|
}
|
|
}
|
|
function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
|
|
const program = resolutionHost.getCurrentProgram();
|
|
if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
|
|
resolutions.forEach(watchFailedLookupLocationOfResolution);
|
|
} else {
|
|
resolutions.forEach((resolution) => watchAffectingLocationsOfResolution(resolution, true));
|
|
}
|
|
}
|
|
function setDirectoryWatcher(dir, dirPath, nonRecursive) {
|
|
const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
|
|
if (dirWatcher) {
|
|
Debug.assert(!!nonRecursive === !!dirWatcher.nonRecursive);
|
|
dirWatcher.refCount++;
|
|
} else {
|
|
directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive });
|
|
}
|
|
}
|
|
function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
|
|
unorderedRemoveItem(Debug.checkDefined(resolution.files), filePath);
|
|
resolution.refCount--;
|
|
if (resolution.refCount) {
|
|
return;
|
|
}
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
if (resolved && resolved.resolvedFileName) {
|
|
resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
|
|
}
|
|
const { failedLookupLocations, affectingLocations } = resolution;
|
|
if (unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
|
|
let removeAtRoot = false;
|
|
for (const failedLookupLocation of failedLookupLocations) {
|
|
const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
|
|
const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
|
|
if (toWatch) {
|
|
const { dirPath } = toWatch;
|
|
const refCount = customFailedLookupPaths.get(failedLookupLocationPath);
|
|
if (refCount) {
|
|
if (refCount === 1) {
|
|
customFailedLookupPaths.delete(failedLookupLocationPath);
|
|
} else {
|
|
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) {
|
|
unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
|
|
}
|
|
for (const affectingLocation of affectingLocations) {
|
|
const watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
|
|
watcher.resolutions--;
|
|
}
|
|
}
|
|
function removeDirectoryWatcher(dirPath) {
|
|
const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
|
|
dirWatcher.refCount--;
|
|
}
|
|
function createDirectoryWatcher(directory, dirPath, nonRecursive) {
|
|
return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, (fileOrDirectory) => {
|
|
const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
|
|
}, nonRecursive ? 0 /* None */ : 1 /* Recursive */);
|
|
}
|
|
function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
|
|
const resolutions = cache.get(filePath);
|
|
if (resolutions) {
|
|
resolutions.forEach((resolution) => stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName));
|
|
cache.delete(filePath);
|
|
}
|
|
}
|
|
function removeResolutionsFromProjectReferenceRedirects(filePath) {
|
|
if (!fileExtensionIs(filePath, ".json" /* Json */))
|
|
return;
|
|
const program = resolutionHost.getCurrentProgram();
|
|
if (!program)
|
|
return;
|
|
const resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath);
|
|
if (!resolvedProjectReference)
|
|
return;
|
|
resolvedProjectReference.commandLine.fileNames.forEach((f) => removeResolutionsOfFile(resolutionHost.toPath(f)));
|
|
}
|
|
function removeResolutionsOfFile(filePath) {
|
|
removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule2);
|
|
removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective2);
|
|
}
|
|
function invalidateResolutions(resolutions, canInvalidate) {
|
|
if (!resolutions)
|
|
return false;
|
|
let invalidated = false;
|
|
for (const resolution of resolutions) {
|
|
if (resolution.isInvalidated || !canInvalidate(resolution))
|
|
continue;
|
|
resolution.isInvalidated = invalidated = true;
|
|
for (const containingFilePath of Debug.checkDefined(resolution.files)) {
|
|
(filesWithInvalidatedResolutions != null ? filesWithInvalidatedResolutions : filesWithInvalidatedResolutions = /* @__PURE__ */ new Set()).add(containingFilePath);
|
|
hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || endsWith(containingFilePath, inferredTypesContainingFile);
|
|
}
|
|
}
|
|
return invalidated;
|
|
}
|
|
function invalidateResolutionOfFile(filePath) {
|
|
removeResolutionsOfFile(filePath);
|
|
const prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
|
|
if (invalidateResolutions(resolvedFileToResolution.get(filePath), returnTrue) && hasChangedAutomaticTypeDirectiveNames && !prevHasChangedAutomaticTypeDirectiveNames) {
|
|
resolutionHost.onChangedAutomaticTypeDirectiveNames();
|
|
}
|
|
}
|
|
function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) {
|
|
Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === void 0);
|
|
filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
|
|
}
|
|
function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
|
|
if (isCreatingWatchedDirectory) {
|
|
(isInDirectoryChecks || (isInDirectoryChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
} else {
|
|
const updatedPath = removeIgnoredPath(fileOrDirectoryPath);
|
|
if (!updatedPath)
|
|
return false;
|
|
fileOrDirectoryPath = updatedPath;
|
|
if (resolutionHost.fileIsOpen(fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
const dirOfFileOrDirectory = getDirectoryPath(fileOrDirectoryPath);
|
|
if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || isNodeModulesDirectory(fileOrDirectoryPath) || isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || isNodeModulesDirectory(dirOfFileOrDirectory)) {
|
|
(failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
(startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
} else {
|
|
if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
(failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
const packagePath = parseNodeModuleFromPath(fileOrDirectoryPath);
|
|
if (packagePath)
|
|
(startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(packagePath);
|
|
}
|
|
}
|
|
resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
|
|
}
|
|
function invalidateResolutionsOfFailedLookupLocations() {
|
|
var _a2;
|
|
let invalidated = false;
|
|
if (affectingPathChecksForFile) {
|
|
(_a2 = resolutionHost.getCurrentProgram()) == null ? void 0 : _a2.getSourceFiles().forEach((f) => {
|
|
if (some(f.packageJsonLocations, (location) => affectingPathChecksForFile.has(location))) {
|
|
(filesWithInvalidatedResolutions != null ? filesWithInvalidatedResolutions : filesWithInvalidatedResolutions = /* @__PURE__ */ new Set()).add(f.path);
|
|
invalidated = true;
|
|
}
|
|
});
|
|
affectingPathChecksForFile = void 0;
|
|
}
|
|
if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) {
|
|
return invalidated;
|
|
}
|
|
invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution) || invalidated;
|
|
const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
|
|
if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
|
|
packageJsonMap.forEach((_value, path) => isInvalidatedFailedLookup(path) ? packageJsonMap.delete(path) : void 0);
|
|
}
|
|
failedLookupChecks = void 0;
|
|
startsWithPathChecks = void 0;
|
|
isInDirectoryChecks = void 0;
|
|
invalidated = invalidateResolutions(resolutionsWithOnlyAffectingLocations, canInvalidatedFailedLookupResolutionWithAffectingLocation) || invalidated;
|
|
affectingPathChecks = void 0;
|
|
return invalidated;
|
|
}
|
|
function canInvalidateFailedLookupResolution(resolution) {
|
|
if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution))
|
|
return true;
|
|
if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
|
|
return false;
|
|
return resolution.failedLookupLocations.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
|
|
}
|
|
function isInvalidatedFailedLookup(locationPath) {
|
|
return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : void 0);
|
|
}
|
|
function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
|
|
return !!affectingPathChecks && resolution.affectingLocations.some((location) => affectingPathChecks.has(location));
|
|
}
|
|
function closeTypeRootsWatch() {
|
|
clearMap(typeRootsWatches, closeFileWatcher);
|
|
}
|
|
function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath) {
|
|
if (isInDirectoryPath(rootPath, typeRootPath)) {
|
|
return rootPath;
|
|
}
|
|
const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath);
|
|
return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : void 0;
|
|
}
|
|
function createTypeRootsWatch(typeRootPath, typeRoot) {
|
|
return resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
|
|
const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
hasChangedAutomaticTypeDirectiveNames = true;
|
|
resolutionHost.onChangedAutomaticTypeDirectiveNames();
|
|
const dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath);
|
|
if (dirPath) {
|
|
scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
|
|
}
|
|
}, 1 /* Recursive */);
|
|
}
|
|
function updateTypeRootsWatch() {
|
|
const options = resolutionHost.getCompilationSettings();
|
|
if (options.types) {
|
|
closeTypeRootsWatch();
|
|
return;
|
|
}
|
|
const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
|
|
if (typeRoots) {
|
|
mutateMap(
|
|
typeRootsWatches,
|
|
arrayToMap(typeRoots, (tr) => resolutionHost.toPath(tr)),
|
|
{
|
|
createNewValue: createTypeRootsWatch,
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
} else {
|
|
closeTypeRootsWatch();
|
|
}
|
|
}
|
|
function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
|
|
const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
|
|
const dirPath = resolutionHost.toPath(dir);
|
|
return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
|
|
}
|
|
}
|
|
function resolutionIsSymlink(resolution) {
|
|
var _a2, _b;
|
|
return !!(((_a2 = resolution.resolvedModule) == null ? void 0 : _a2.originalPath) || ((_b = resolution.resolvedTypeReferenceDirective) == null ? void 0 : _b.originalPath));
|
|
}
|
|
|
|
// src/compiler/watch.ts
|
|
var sysFormatDiagnosticsHost = sys ? {
|
|
getCurrentDirectory: () => sys.getCurrentDirectory(),
|
|
getNewLine: () => sys.newLine,
|
|
getCanonicalFileName: createGetCanonicalFileName(sys.useCaseSensitiveFileNames)
|
|
} : void 0;
|
|
function createDiagnosticReporter(system, pretty) {
|
|
const host = system === sys && sysFormatDiagnosticsHost ? sysFormatDiagnosticsHost : {
|
|
getCurrentDirectory: () => system.getCurrentDirectory(),
|
|
getNewLine: () => system.newLine,
|
|
getCanonicalFileName: createGetCanonicalFileName(system.useCaseSensitiveFileNames)
|
|
};
|
|
if (!pretty) {
|
|
return (diagnostic) => system.write(formatDiagnostic(diagnostic, host));
|
|
}
|
|
const diagnostics = new Array(1);
|
|
return (diagnostic) => {
|
|
diagnostics[0] = diagnostic;
|
|
system.write(formatDiagnosticsWithColorAndContext(diagnostics, host) + host.getNewLine());
|
|
diagnostics[0] = void 0;
|
|
};
|
|
}
|
|
function clearScreenIfNotWatchingForFileChanges(system, diagnostic, options) {
|
|
if (system.clearScreen && !options.preserveWatchOutput && !options.extendedDiagnostics && !options.diagnostics && contains(screenStartingMessageCodes, diagnostic.code)) {
|
|
system.clearScreen();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
var screenStartingMessageCodes = [
|
|
Diagnostics.Starting_compilation_in_watch_mode.code,
|
|
Diagnostics.File_change_detected_Starting_incremental_compilation.code
|
|
];
|
|
function getPlainDiagnosticFollowingNewLines(diagnostic, newLine) {
|
|
return contains(screenStartingMessageCodes, diagnostic.code) ? newLine + newLine : newLine;
|
|
}
|
|
function getLocaleTimeString(system) {
|
|
return !system.now ? new Date().toLocaleTimeString() : system.now().toLocaleTimeString("en-US", { timeZone: "UTC" });
|
|
}
|
|
function createWatchStatusReporter(system, pretty) {
|
|
return pretty ? (diagnostic, newLine, options) => {
|
|
clearScreenIfNotWatchingForFileChanges(system, diagnostic, options);
|
|
let output = `[${formatColorAndReset(getLocaleTimeString(system), "\x1B[90m" /* Grey */)}] `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${newLine + newLine}`;
|
|
system.write(output);
|
|
} : (diagnostic, newLine, options) => {
|
|
let output = "";
|
|
if (!clearScreenIfNotWatchingForFileChanges(system, diagnostic, options)) {
|
|
output += newLine;
|
|
}
|
|
output += `${getLocaleTimeString(system)} - `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${getPlainDiagnosticFollowingNewLines(diagnostic, newLine)}`;
|
|
system.write(output);
|
|
};
|
|
}
|
|
function parseConfigFileWithSystem(configFileName, optionsToExtend, extendedConfigCache, watchOptionsToExtend, system, reportDiagnostic) {
|
|
const host = system;
|
|
host.onUnRecoverableConfigFileDiagnostic = (diagnostic) => reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic);
|
|
const result = getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend);
|
|
host.onUnRecoverableConfigFileDiagnostic = void 0;
|
|
return result;
|
|
}
|
|
function getErrorCountForSummary(diagnostics) {
|
|
return countWhere(diagnostics, (diagnostic) => diagnostic.category === 1 /* Error */);
|
|
}
|
|
function getFilesInErrorForSummary(diagnostics) {
|
|
const filesInError = filter(diagnostics, (diagnostic) => diagnostic.category === 1 /* Error */).map(
|
|
(errorDiagnostic) => {
|
|
if (errorDiagnostic.file === void 0)
|
|
return;
|
|
return `${errorDiagnostic.file.fileName}`;
|
|
}
|
|
);
|
|
return filesInError.map((fileName) => {
|
|
const diagnosticForFileName = find(
|
|
diagnostics,
|
|
(diagnostic) => diagnostic.file !== void 0 && diagnostic.file.fileName === fileName
|
|
);
|
|
if (diagnosticForFileName !== void 0) {
|
|
const { line } = getLineAndCharacterOfPosition(diagnosticForFileName.file, diagnosticForFileName.start);
|
|
return {
|
|
fileName,
|
|
line: line + 1
|
|
};
|
|
}
|
|
});
|
|
}
|
|
function getWatchErrorSummaryDiagnosticMessage(errorCount) {
|
|
return errorCount === 1 ? Diagnostics.Found_1_error_Watching_for_file_changes : Diagnostics.Found_0_errors_Watching_for_file_changes;
|
|
}
|
|
function prettyPathForFileError(error, cwd) {
|
|
const line = formatColorAndReset(":" + error.line, "\x1B[90m" /* Grey */);
|
|
if (pathIsAbsolute(error.fileName) && pathIsAbsolute(cwd)) {
|
|
return getRelativePathFromDirectory(cwd, error.fileName, false) + line;
|
|
}
|
|
return error.fileName + line;
|
|
}
|
|
function getErrorSummaryText(errorCount, filesInError, newLine, host) {
|
|
if (errorCount === 0)
|
|
return "";
|
|
const nonNilFiles = filesInError.filter((fileInError) => fileInError !== void 0);
|
|
const distinctFileNamesWithLines = nonNilFiles.map((fileInError) => `${fileInError.fileName}:${fileInError.line}`).filter((value, index, self) => self.indexOf(value) === index);
|
|
const firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory());
|
|
const d = errorCount === 1 ? createCompilerDiagnostic(
|
|
filesInError[0] !== void 0 ? Diagnostics.Found_1_error_in_1 : Diagnostics.Found_1_error,
|
|
errorCount,
|
|
firstFileReference
|
|
) : createCompilerDiagnostic(
|
|
distinctFileNamesWithLines.length === 0 ? Diagnostics.Found_0_errors : distinctFileNamesWithLines.length === 1 ? Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 : Diagnostics.Found_0_errors_in_1_files,
|
|
errorCount,
|
|
distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length
|
|
);
|
|
const suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "";
|
|
return `${newLine}${flattenDiagnosticMessageText(d.messageText, newLine)}${newLine}${newLine}${suffix}`;
|
|
}
|
|
function createTabularErrorsDisplay(filesInError, host) {
|
|
const distinctFiles = filesInError.filter((value, index, self) => index === self.findIndex((file) => (file == null ? void 0 : file.fileName) === (value == null ? void 0 : value.fileName)));
|
|
if (distinctFiles.length === 0)
|
|
return "";
|
|
const numberLength = (num) => Math.log(num) * Math.LOG10E + 1;
|
|
const fileToErrorCount = distinctFiles.map((file) => [file, countWhere(filesInError, (fileInError) => fileInError.fileName === file.fileName)]);
|
|
const maxErrors = fileToErrorCount.reduce((acc, value) => Math.max(acc, value[1] || 0), 0);
|
|
const headerRow = Diagnostics.Errors_Files.message;
|
|
const leftColumnHeadingLength = headerRow.split(" ")[0].length;
|
|
const leftPaddingGoal = Math.max(leftColumnHeadingLength, numberLength(maxErrors));
|
|
const headerPadding = Math.max(numberLength(maxErrors) - leftColumnHeadingLength, 0);
|
|
let tabularData = "";
|
|
tabularData += " ".repeat(headerPadding) + headerRow + "\n";
|
|
fileToErrorCount.forEach((row) => {
|
|
const [file, errorCount] = row;
|
|
const errorCountDigitsLength = Math.log(errorCount) * Math.LOG10E + 1 | 0;
|
|
const leftPadding = errorCountDigitsLength < leftPaddingGoal ? " ".repeat(leftPaddingGoal - errorCountDigitsLength) : "";
|
|
const fileRef = prettyPathForFileError(file, host.getCurrentDirectory());
|
|
tabularData += `${leftPadding}${errorCount} ${fileRef}
|
|
`;
|
|
});
|
|
return tabularData;
|
|
}
|
|
function isBuilderProgram2(program) {
|
|
return !!program.getState;
|
|
}
|
|
function listFiles(program, write) {
|
|
const options = program.getCompilerOptions();
|
|
if (options.explainFiles) {
|
|
explainFiles(isBuilderProgram2(program) ? program.getProgram() : program, write);
|
|
} else if (options.listFiles || options.listFilesOnly) {
|
|
forEach(program.getSourceFiles(), (file) => {
|
|
write(file.fileName);
|
|
});
|
|
}
|
|
}
|
|
function explainFiles(program, write) {
|
|
var _a2, _b;
|
|
const reasons = program.getFileIncludeReasons();
|
|
const getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames());
|
|
const relativeFileName = (fileName) => convertToRelativePath(fileName, program.getCurrentDirectory(), getCanonicalFileName);
|
|
for (const file of program.getSourceFiles()) {
|
|
write(`${toFileName(file, relativeFileName)}`);
|
|
(_a2 = reasons.get(file.path)) == null ? void 0 : _a2.forEach((reason) => write(` ${fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText}`));
|
|
(_b = explainIfFileIsRedirectAndImpliedFormat(file, relativeFileName)) == null ? void 0 : _b.forEach((d) => write(` ${d.messageText}`));
|
|
}
|
|
}
|
|
function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
|
|
var _a2;
|
|
let result;
|
|
if (file.path !== file.resolvedPath) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_output_of_project_reference_source_0,
|
|
toFileName(file.originalFileName, fileNameConvertor)
|
|
));
|
|
}
|
|
if (file.redirectInfo) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_redirects_to_file_0,
|
|
toFileName(file.redirectInfo.redirectTarget, fileNameConvertor)
|
|
));
|
|
}
|
|
if (isExternalOrCommonJsModule(file)) {
|
|
switch (file.impliedNodeFormat) {
|
|
case 99 /* ESNext */:
|
|
if (file.packageJsonScope) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module,
|
|
toFileName(last(file.packageJsonLocations), fileNameConvertor)
|
|
));
|
|
}
|
|
break;
|
|
case 1 /* CommonJS */:
|
|
if (file.packageJsonScope) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
file.packageJsonScope.contents.packageJsonContent.type ? Diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module : Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type,
|
|
toFileName(last(file.packageJsonLocations), fileNameConvertor)
|
|
));
|
|
} else if ((_a2 = file.packageJsonLocations) == null ? void 0 : _a2.length) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_CommonJS_module_because_package_json_was_not_found
|
|
));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getMatchedFileSpec(program, fileName) {
|
|
var _a2;
|
|
const configFile = program.getCompilerOptions().configFile;
|
|
if (!((_a2 = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _a2.validatedFilesSpec))
|
|
return void 0;
|
|
const getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames());
|
|
const filePath = getCanonicalFileName(fileName);
|
|
const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
|
|
return find(configFile.configFileSpecs.validatedFilesSpec, (fileSpec) => getCanonicalFileName(getNormalizedAbsolutePath(fileSpec, basePath)) === filePath);
|
|
}
|
|
function getMatchedIncludeSpec(program, fileName) {
|
|
var _a2, _b;
|
|
const configFile = program.getCompilerOptions().configFile;
|
|
if (!((_a2 = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _a2.validatedIncludeSpecs))
|
|
return void 0;
|
|
if (configFile.configFileSpecs.isDefaultIncludeSpec)
|
|
return true;
|
|
const isJsonFile = fileExtensionIs(fileName, ".json" /* Json */);
|
|
const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
|
|
const useCaseSensitiveFileNames = program.useCaseSensitiveFileNames();
|
|
return find((_b = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _b.validatedIncludeSpecs, (includeSpec) => {
|
|
if (isJsonFile && !endsWith(includeSpec, ".json" /* Json */))
|
|
return false;
|
|
const pattern = getPatternFromSpec(includeSpec, basePath, "files");
|
|
return !!pattern && getRegexFromPattern(`(${pattern})$`, useCaseSensitiveFileNames).test(fileName);
|
|
});
|
|
}
|
|
function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
|
|
var _a2, _b;
|
|
const options = program.getCompilerOptions();
|
|
if (isReferencedFile(reason)) {
|
|
const referenceLocation = getReferencedFileLocation((path) => program.getSourceFileByPath(path), reason);
|
|
const referenceText = isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : `"${referenceLocation.text}"`;
|
|
let message;
|
|
Debug.assert(isReferenceFileLocation(referenceLocation) || reason.kind === 3 /* Import */, "Only synthetic references are imports");
|
|
switch (reason.kind) {
|
|
case 3 /* Import */:
|
|
if (isReferenceFileLocation(referenceLocation)) {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2 : Diagnostics.Imported_via_0_from_file_1;
|
|
} else if (referenceLocation.text === externalHelpersModuleNameText) {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions : Diagnostics.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions;
|
|
} else {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions : Diagnostics.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions;
|
|
}
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
Debug.assert(!referenceLocation.packageId);
|
|
message = Diagnostics.Referenced_via_0_from_file_1;
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
message = referenceLocation.packageId ? Diagnostics.Type_library_referenced_via_0_from_file_1_with_packageId_2 : Diagnostics.Type_library_referenced_via_0_from_file_1;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
Debug.assert(!referenceLocation.packageId);
|
|
message = Diagnostics.Library_referenced_via_0_from_file_1;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
message,
|
|
referenceText,
|
|
toFileName(referenceLocation.file, fileNameConvertor),
|
|
referenceLocation.packageId && packageIdToString(referenceLocation.packageId)
|
|
);
|
|
}
|
|
switch (reason.kind) {
|
|
case 0 /* RootFile */:
|
|
if (!((_a2 = options.configFile) == null ? void 0 : _a2.configFileSpecs))
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Root_file_specified_for_compilation);
|
|
const fileName = getNormalizedAbsolutePath(program.getRootFileNames()[reason.index], program.getCurrentDirectory());
|
|
const matchedByFiles = getMatchedFileSpec(program, fileName);
|
|
if (matchedByFiles)
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Part_of_files_list_in_tsconfig_json);
|
|
const matchedByInclude = getMatchedIncludeSpec(program, fileName);
|
|
return isString(matchedByInclude) ? chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.Matched_by_include_pattern_0_in_1,
|
|
matchedByInclude,
|
|
toFileName(options.configFile, fileNameConvertor)
|
|
) : chainDiagnosticMessages(
|
|
void 0,
|
|
matchedByInclude ? Diagnostics.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk : Diagnostics.Root_file_specified_for_compilation
|
|
);
|
|
case 1 /* SourceFromProjectReference */:
|
|
case 2 /* OutputFromProjectReference */:
|
|
const isOutput = reason.kind === 2 /* OutputFromProjectReference */;
|
|
const referencedResolvedRef = Debug.checkDefined((_b = program.getResolvedProjectReferences()) == null ? void 0 : _b[reason.index]);
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
outFile(options) ? isOutput ? Diagnostics.Output_from_referenced_project_0_included_because_1_specified : Diagnostics.Source_from_referenced_project_0_included_because_1_specified : isOutput ? Diagnostics.Output_from_referenced_project_0_included_because_module_is_specified_as_none : Diagnostics.Source_from_referenced_project_0_included_because_module_is_specified_as_none,
|
|
toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor),
|
|
options.outFile ? "--outFile" : "--out"
|
|
);
|
|
case 8 /* AutomaticTypeDirectiveFile */:
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
options.types ? reason.packageId ? Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : reason.packageId ? Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : Diagnostics.Entry_point_for_implicit_type_library_0,
|
|
reason.typeReference,
|
|
reason.packageId && packageIdToString(reason.packageId)
|
|
);
|
|
case 6 /* LibFile */:
|
|
if (reason.index !== void 0)
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Library_0_specified_in_compilerOptions, options.lib[reason.index]);
|
|
const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
target ? Diagnostics.Default_library_for_target_0 : Diagnostics.Default_library,
|
|
target
|
|
);
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
}
|
|
function toFileName(file, fileNameConvertor) {
|
|
const fileName = isString(file) ? file : file.fileName;
|
|
return fileNameConvertor ? fileNameConvertor(fileName) : fileName;
|
|
}
|
|
function emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
const isListFilesOnly = !!program.getCompilerOptions().listFilesOnly;
|
|
const allDiagnostics = program.getConfigFileParsingDiagnostics().slice();
|
|
const configFileParsingDiagnosticsLength = allDiagnostics.length;
|
|
addRange(allDiagnostics, program.getSyntacticDiagnostics(void 0, cancellationToken));
|
|
if (allDiagnostics.length === configFileParsingDiagnosticsLength) {
|
|
addRange(allDiagnostics, program.getOptionsDiagnostics(cancellationToken));
|
|
if (!isListFilesOnly) {
|
|
addRange(allDiagnostics, program.getGlobalDiagnostics(cancellationToken));
|
|
if (allDiagnostics.length === configFileParsingDiagnosticsLength) {
|
|
addRange(allDiagnostics, program.getSemanticDiagnostics(void 0, cancellationToken));
|
|
}
|
|
}
|
|
}
|
|
const emitResult = isListFilesOnly ? { emitSkipped: true, diagnostics: emptyArray } : program.emit(void 0, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers);
|
|
const { emittedFiles, diagnostics: emitDiagnostics } = emitResult;
|
|
addRange(allDiagnostics, emitDiagnostics);
|
|
const diagnostics = sortAndDeduplicateDiagnostics(allDiagnostics);
|
|
diagnostics.forEach(reportDiagnostic);
|
|
if (write) {
|
|
const currentDir = program.getCurrentDirectory();
|
|
forEach(emittedFiles, (file) => {
|
|
const filepath = getNormalizedAbsolutePath(file, currentDir);
|
|
write(`TSFILE: ${filepath}`);
|
|
});
|
|
listFiles(program, write);
|
|
}
|
|
if (reportSummary) {
|
|
reportSummary(getErrorCountForSummary(diagnostics), getFilesInErrorForSummary(diagnostics));
|
|
}
|
|
return {
|
|
emitResult,
|
|
diagnostics
|
|
};
|
|
}
|
|
function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, write, reportSummary, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
const { emitResult, diagnostics } = emitFilesAndReportErrors(
|
|
program,
|
|
reportDiagnostic,
|
|
write,
|
|
reportSummary,
|
|
writeFile2,
|
|
cancellationToken,
|
|
emitOnlyDtsFiles,
|
|
customTransformers
|
|
);
|
|
if (emitResult.emitSkipped && diagnostics.length > 0) {
|
|
return 1 /* DiagnosticsPresent_OutputsSkipped */;
|
|
} else if (diagnostics.length > 0) {
|
|
return 2 /* DiagnosticsPresent_OutputsGenerated */;
|
|
}
|
|
return 0 /* Success */;
|
|
}
|
|
var noopFileWatcher = { close: noop };
|
|
var returnNoopFileWatcher = () => noopFileWatcher;
|
|
function createWatchHost(system = sys, reportWatchStatus2) {
|
|
const onWatchStatusChange = reportWatchStatus2 || createWatchStatusReporter(system);
|
|
return {
|
|
onWatchStatusChange,
|
|
watchFile: maybeBind(system, system.watchFile) || returnNoopFileWatcher,
|
|
watchDirectory: maybeBind(system, system.watchDirectory) || returnNoopFileWatcher,
|
|
setTimeout: maybeBind(system, system.setTimeout) || noop,
|
|
clearTimeout: maybeBind(system, system.clearTimeout) || noop
|
|
};
|
|
}
|
|
var 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) {
|
|
const watchLogLevel = host.trace ? options.extendedDiagnostics ? 2 /* Verbose */ : options.diagnostics ? 1 /* TriggerOnly */ : 0 /* None */ : 0 /* None */;
|
|
const writeLog = watchLogLevel !== 0 /* None */ ? (s) => host.trace(s) : noop;
|
|
const result = getWatchFactory(host, watchLogLevel, writeLog);
|
|
result.writeLog = writeLog;
|
|
return result;
|
|
}
|
|
function createCompilerHostFromProgramHost(host, getCompilerOptions, directoryStructureHost = host) {
|
|
const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
|
|
const hostGetNewLine = memoize(() => host.getNewLine());
|
|
return {
|
|
getSourceFile: createGetSourceFile(
|
|
(fileName, encoding) => host.readFile(fileName, encoding),
|
|
getCompilerOptions,
|
|
void 0
|
|
),
|
|
getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
|
|
getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
|
|
writeFile: createWriteFileMeasuringIO(
|
|
(path, data, writeByteOrderMark) => host.writeFile(path, data, writeByteOrderMark),
|
|
(path) => host.createDirectory(path),
|
|
(path) => host.directoryExists(path)
|
|
),
|
|
getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
|
|
useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
|
|
getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames),
|
|
getNewLine: () => getNewLineCharacter(getCompilerOptions(), hostGetNewLine),
|
|
fileExists: (f) => host.fileExists(f),
|
|
readFile: (f) => host.readFile(f),
|
|
trace: maybeBind(host, host.trace),
|
|
directoryExists: maybeBind(directoryStructureHost, directoryStructureHost.directoryExists),
|
|
getDirectories: maybeBind(directoryStructureHost, directoryStructureHost.getDirectories),
|
|
realpath: maybeBind(host, host.realpath),
|
|
getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
|
|
createHash: maybeBind(host, host.createHash),
|
|
readDirectory: maybeBind(host, host.readDirectory),
|
|
disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
|
|
storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
|
|
};
|
|
}
|
|
function getSourceFileVersionAsHashFromText(host, text) {
|
|
if (text.match(sourceMapCommentRegExpDontCareLineStart)) {
|
|
let lineEnd = text.length;
|
|
let lineStart = lineEnd;
|
|
for (let pos = lineEnd - 1; pos >= 0; pos--) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 10 /* lineFeed */:
|
|
if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) {
|
|
pos--;
|
|
}
|
|
case 13 /* carriageReturn */:
|
|
break;
|
|
default:
|
|
if (ch < 127 /* maxAsciiCharacter */ || !isLineBreak(ch)) {
|
|
lineStart = pos;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
const line = text.substring(lineStart, lineEnd);
|
|
if (line.match(sourceMapCommentRegExp)) {
|
|
text = text.substring(0, lineStart);
|
|
break;
|
|
} else if (!line.match(whitespaceOrMapCommentRegExp)) {
|
|
break;
|
|
}
|
|
lineEnd = lineStart;
|
|
}
|
|
}
|
|
return (host.createHash || generateDjb2Hash)(text);
|
|
}
|
|
function setGetSourceFileAsHashVersioned(compilerHost, host) {
|
|
const originalGetSourceFile = compilerHost.getSourceFile;
|
|
compilerHost.getSourceFile = (...args) => {
|
|
const result = originalGetSourceFile.call(compilerHost, ...args);
|
|
if (result) {
|
|
result.version = getSourceFileVersionAsHashFromText(host, result.text);
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
function createProgramHost(system, createProgram2) {
|
|
const getDefaultLibLocation = memoize(() => getDirectoryPath(normalizePath(system.getExecutingFilePath())));
|
|
return {
|
|
useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
|
|
getNewLine: () => system.newLine,
|
|
getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
|
|
getDefaultLibLocation,
|
|
getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
|
|
fileExists: (path) => system.fileExists(path),
|
|
readFile: (path, encoding) => system.readFile(path, encoding),
|
|
directoryExists: (path) => system.directoryExists(path),
|
|
getDirectories: (path) => system.getDirectories(path),
|
|
readDirectory: (path, extensions, exclude, include, depth) => system.readDirectory(path, extensions, exclude, include, depth),
|
|
realpath: maybeBind(system, system.realpath),
|
|
getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
|
|
trace: (s) => system.write(s + system.newLine),
|
|
createDirectory: (path) => system.createDirectory(path),
|
|
writeFile: (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
|
|
createHash: maybeBind(system, system.createHash),
|
|
createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
|
|
disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
|
|
storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
|
|
now: maybeBind(system, system.now)
|
|
};
|
|
}
|
|
function createWatchCompilerHost(system = sys, createProgram2, reportDiagnostic, reportWatchStatus2) {
|
|
const write = (s) => system.write(s + system.newLine);
|
|
const result = createProgramHost(system, createProgram2);
|
|
copyProperties(result, createWatchHost(system, reportWatchStatus2));
|
|
result.afterProgramCreate = (builderProgram) => {
|
|
const compilerOptions = builderProgram.getCompilerOptions();
|
|
const newLine = getNewLineCharacter(compilerOptions, () => system.newLine);
|
|
emitFilesAndReportErrors(
|
|
builderProgram,
|
|
reportDiagnostic,
|
|
write,
|
|
(errorCount) => result.onWatchStatusChange(
|
|
createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount),
|
|
newLine,
|
|
compilerOptions,
|
|
errorCount
|
|
)
|
|
);
|
|
};
|
|
return result;
|
|
}
|
|
function reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic) {
|
|
reportDiagnostic(diagnostic);
|
|
system.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
function createWatchCompilerHostOfConfigFile({
|
|
configFileName,
|
|
optionsToExtend,
|
|
watchOptionsToExtend,
|
|
extraFileExtensions,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
}) {
|
|
const diagnosticReporter = reportDiagnostic || createDiagnosticReporter(system);
|
|
const host = createWatchCompilerHost(system, createProgram2, diagnosticReporter, reportWatchStatus2);
|
|
host.onUnRecoverableConfigFileDiagnostic = (diagnostic) => reportUnrecoverableDiagnostic(system, diagnosticReporter, diagnostic);
|
|
host.configFileName = configFileName;
|
|
host.optionsToExtend = optionsToExtend;
|
|
host.watchOptionsToExtend = watchOptionsToExtend;
|
|
host.extraFileExtensions = extraFileExtensions;
|
|
return host;
|
|
}
|
|
function createWatchCompilerHostOfFilesAndCompilerOptions({
|
|
rootFiles,
|
|
options,
|
|
watchOptions,
|
|
projectReferences,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
}) {
|
|
const host = createWatchCompilerHost(system, createProgram2, reportDiagnostic || createDiagnosticReporter(system), reportWatchStatus2);
|
|
host.rootFiles = rootFiles;
|
|
host.options = options;
|
|
host.watchOptions = watchOptions;
|
|
host.projectReferences = projectReferences;
|
|
return host;
|
|
}
|
|
function performIncrementalCompilation(input) {
|
|
const system = input.system || sys;
|
|
const host = input.host || (input.host = createIncrementalCompilerHost(input.options, system));
|
|
const builderProgram = createIncrementalProgram(input);
|
|
const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
|
|
builderProgram,
|
|
input.reportDiagnostic || createDiagnosticReporter(system),
|
|
(s) => host.trace && host.trace(s),
|
|
input.reportErrorSummary || input.options.pretty ? (errorCount, filesInError) => system.write(getErrorSummaryText(errorCount, filesInError, system.newLine, host)) : void 0
|
|
);
|
|
if (input.afterProgramEmitAndDiagnostics)
|
|
input.afterProgramEmitAndDiagnostics(builderProgram);
|
|
return exitStatus;
|
|
}
|
|
|
|
// src/compiler/watchPublic.ts
|
|
function readBuilderProgram(compilerOptions, host) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(compilerOptions);
|
|
if (!buildInfoPath)
|
|
return void 0;
|
|
let buildInfo;
|
|
if (host.getBuildInfo) {
|
|
buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath);
|
|
} else {
|
|
const content = host.readFile(buildInfoPath);
|
|
if (!content)
|
|
return void 0;
|
|
buildInfo = getBuildInfo(buildInfoPath, content);
|
|
}
|
|
if (!buildInfo || buildInfo.version !== version || !buildInfo.program)
|
|
return void 0;
|
|
return createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, host);
|
|
}
|
|
function createIncrementalCompilerHost(options, system = sys) {
|
|
const host = createCompilerHostWorker(options, void 0, system);
|
|
host.createHash = maybeBind(system, system.createHash);
|
|
host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
|
|
host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
|
|
setGetSourceFileAsHashVersioned(host, system);
|
|
changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
|
|
return host;
|
|
}
|
|
function createIncrementalProgram({
|
|
rootNames,
|
|
options,
|
|
configFileParsingDiagnostics,
|
|
projectReferences,
|
|
host,
|
|
createProgram: createProgram2
|
|
}) {
|
|
host = host || createIncrementalCompilerHost(options);
|
|
createProgram2 = createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram;
|
|
const oldProgram = readBuilderProgram(options, host);
|
|
return createProgram2(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences);
|
|
}
|
|
function createWatchProgram(host) {
|
|
let builderProgram;
|
|
let reloadLevel;
|
|
let missingFilesMap;
|
|
let watchedWildcardDirectories;
|
|
let timerToUpdateProgram;
|
|
let timerToInvalidateFailedLookupResolutions;
|
|
let parsedConfigs;
|
|
let sharedExtendedConfigFileWatchers;
|
|
let extendedConfigCache = host.extendedConfigCache;
|
|
let reportFileChangeDetectedOnCreateProgram = false;
|
|
const sourceFilesCache = /* @__PURE__ */ new Map();
|
|
let missingFilePathsRequestedForRelease;
|
|
let hasChangedCompilerOptions = false;
|
|
const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const { configFileName, optionsToExtend: optionsToExtendForConfigFile = {}, watchOptionsToExtend, extraFileExtensions, createProgram: createProgram2 } = host;
|
|
let { rootFiles: rootFileNames, options: compilerOptions, watchOptions, projectReferences } = host;
|
|
let wildcardDirectories;
|
|
let configFileParsingDiagnostics;
|
|
let canConfigFileJsonReportNoInputFiles = false;
|
|
let hasChangedConfigFileParsingErrors = false;
|
|
const cachedDirectoryStructureHost = configFileName === void 0 ? void 0 : createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames);
|
|
const directoryStructureHost = cachedDirectoryStructureHost || host;
|
|
const parseConfigFileHost = parseConfigHostFromCompilerHostLike(host, directoryStructureHost);
|
|
let newLine = updateNewLine();
|
|
if (configFileName && host.configFileParsingResult) {
|
|
setConfigFileParsingResult(host.configFileParsingResult);
|
|
newLine = updateNewLine();
|
|
}
|
|
reportWatchDiagnostic(Diagnostics.Starting_compilation_in_watch_mode);
|
|
if (configFileName && !host.configFileParsingResult) {
|
|
newLine = getNewLineCharacter(optionsToExtendForConfigFile, () => host.getNewLine());
|
|
Debug.assert(!rootFileNames);
|
|
parseConfigFile2();
|
|
newLine = updateNewLine();
|
|
}
|
|
const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(host, compilerOptions);
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
writeLog(`Current directory: ${currentDirectory} CaseSensitiveFileNames: ${useCaseSensitiveFileNames}`);
|
|
let configFileWatcher;
|
|
if (configFileName) {
|
|
configFileWatcher = watchFile2(configFileName, scheduleProgramReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile);
|
|
}
|
|
const compilerHost = createCompilerHostFromProgramHost(host, () => compilerOptions, directoryStructureHost);
|
|
setGetSourceFileAsHashVersioned(compilerHost, host);
|
|
const getNewSourceFile = compilerHost.getSourceFile;
|
|
compilerHost.getSourceFile = (fileName, ...args) => getVersionedSourceFileByPath(fileName, toPath3(fileName), ...args);
|
|
compilerHost.getSourceFileByPath = getVersionedSourceFileByPath;
|
|
compilerHost.getNewLine = () => newLine;
|
|
compilerHost.fileExists = fileExists;
|
|
compilerHost.onReleaseOldSourceFile = onReleaseOldSourceFile;
|
|
compilerHost.onReleaseParsedCommandLine = onReleaseParsedCommandLine;
|
|
compilerHost.toPath = toPath3;
|
|
compilerHost.getCompilationSettings = () => compilerOptions;
|
|
compilerHost.useSourceOfProjectReferenceRedirect = maybeBind(host, host.useSourceOfProjectReferenceRedirect);
|
|
compilerHost.watchDirectoryOfFailedLookupLocation = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.FailedLookupLocations);
|
|
compilerHost.watchAffectingFileLocation = (file, cb) => watchFile2(file, cb, 2e3 /* High */, watchOptions, WatchType.AffectingFileLocation);
|
|
compilerHost.watchTypeRootsDirectory = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.TypeRoots);
|
|
compilerHost.getCachedDirectoryStructureHost = () => cachedDirectoryStructureHost;
|
|
compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations;
|
|
compilerHost.onInvalidatedResolution = scheduleProgramUpdate;
|
|
compilerHost.onChangedAutomaticTypeDirectiveNames = scheduleProgramUpdate;
|
|
compilerHost.fileIsOpen = returnFalse;
|
|
compilerHost.getCurrentProgram = getCurrentProgram;
|
|
compilerHost.writeLog = writeLog;
|
|
compilerHost.getParsedCommandLine = getParsedCommandLine;
|
|
const resolutionCache = createResolutionCache(
|
|
compilerHost,
|
|
configFileName ? getDirectoryPath(getNormalizedAbsolutePath(configFileName, currentDirectory)) : currentDirectory,
|
|
false
|
|
);
|
|
compilerHost.resolveModuleNames = host.resolveModuleNames ? (...args) => host.resolveModuleNames(...args) : (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile, resolutionInfo) => resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile, resolutionInfo);
|
|
compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? (...args) => host.resolveTypeReferenceDirectives(...args) : (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) => resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
|
|
compilerHost.getModuleResolutionCache = host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
|
|
const userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
|
|
const customHasInvalidatedResolutions = userProvidedResolution ? maybeBind(host, host.hasInvalidatedResolutions) || returnTrue : returnFalse;
|
|
builderProgram = readBuilderProgram(compilerOptions, compilerHost);
|
|
synchronizeProgram();
|
|
watchConfigFileWildCardDirectories();
|
|
if (configFileName)
|
|
updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
|
|
return configFileName ? { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close } : { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames, close };
|
|
function close() {
|
|
clearInvalidateResolutionsOfFailedLookupLocations();
|
|
resolutionCache.clear();
|
|
clearMap(sourceFilesCache, (value) => {
|
|
if (value && value.fileWatcher) {
|
|
value.fileWatcher.close();
|
|
value.fileWatcher = void 0;
|
|
}
|
|
});
|
|
if (configFileWatcher) {
|
|
configFileWatcher.close();
|
|
configFileWatcher = void 0;
|
|
}
|
|
extendedConfigCache == null ? void 0 : extendedConfigCache.clear();
|
|
extendedConfigCache = void 0;
|
|
if (sharedExtendedConfigFileWatchers) {
|
|
clearMap(sharedExtendedConfigFileWatchers, closeFileWatcherOf);
|
|
sharedExtendedConfigFileWatchers = void 0;
|
|
}
|
|
if (watchedWildcardDirectories) {
|
|
clearMap(watchedWildcardDirectories, closeFileWatcherOf);
|
|
watchedWildcardDirectories = void 0;
|
|
}
|
|
if (missingFilesMap) {
|
|
clearMap(missingFilesMap, closeFileWatcher);
|
|
missingFilesMap = void 0;
|
|
}
|
|
if (parsedConfigs) {
|
|
clearMap(parsedConfigs, (config) => {
|
|
var _a2;
|
|
(_a2 = config.watcher) == null ? void 0 : _a2.close();
|
|
config.watcher = void 0;
|
|
if (config.watchedDirectories)
|
|
clearMap(config.watchedDirectories, closeFileWatcherOf);
|
|
config.watchedDirectories = void 0;
|
|
});
|
|
parsedConfigs = void 0;
|
|
}
|
|
}
|
|
function getCurrentBuilderProgram() {
|
|
return builderProgram;
|
|
}
|
|
function getCurrentProgram() {
|
|
return builderProgram && builderProgram.getProgramOrUndefined();
|
|
}
|
|
function synchronizeProgram() {
|
|
writeLog(`Synchronizing program`);
|
|
clearInvalidateResolutionsOfFailedLookupLocations();
|
|
const program = getCurrentBuilderProgram();
|
|
if (hasChangedCompilerOptions) {
|
|
newLine = updateNewLine();
|
|
if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
|
|
resolutionCache.clear();
|
|
}
|
|
}
|
|
const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions);
|
|
const {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile
|
|
} = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
|
|
if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
|
|
if (hasChangedConfigFileParsingErrors) {
|
|
if (reportFileChangeDetectedOnCreateProgram) {
|
|
reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
|
|
}
|
|
builderProgram = createProgram2(void 0, void 0, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
|
|
hasChangedConfigFileParsingErrors = false;
|
|
}
|
|
} else {
|
|
if (reportFileChangeDetectedOnCreateProgram) {
|
|
reportWatchDiagnostic(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) {
|
|
writeLog("CreatingProgramWith::");
|
|
writeLog(` roots: ${JSON.stringify(rootFileNames)}`);
|
|
writeLog(` options: ${JSON.stringify(compilerOptions)}`);
|
|
if (projectReferences)
|
|
writeLog(` projectReferences: ${JSON.stringify(projectReferences)}`);
|
|
const needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram();
|
|
hasChangedCompilerOptions = false;
|
|
hasChangedConfigFileParsingErrors = false;
|
|
resolutionCache.startCachingPerDirectoryResolution();
|
|
compilerHost.hasInvalidatedResolutions = hasInvalidatedResolutions;
|
|
compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
|
|
const oldProgram = getCurrentProgram();
|
|
builderProgram = createProgram2(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
|
|
resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
|
|
updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = /* @__PURE__ */ new Map()), watchMissingFilePath);
|
|
if (needsUpdateInTypeRootWatch) {
|
|
resolutionCache.updateTypeRootsWatch();
|
|
}
|
|
if (missingFilePathsRequestedForRelease) {
|
|
for (const missingFilePath of missingFilePathsRequestedForRelease) {
|
|
if (!missingFilesMap.has(missingFilePath)) {
|
|
sourceFilesCache.delete(missingFilePath);
|
|
}
|
|
}
|
|
missingFilePathsRequestedForRelease = void 0;
|
|
}
|
|
}
|
|
function updateRootFileNames(files) {
|
|
Debug.assert(!configFileName, "Cannot update root file names with config file watch mode");
|
|
rootFileNames = files;
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateNewLine() {
|
|
return getNewLineCharacter(compilerOptions || optionsToExtendForConfigFile, () => host.getNewLine());
|
|
}
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function isFileMissingOnHost(hostSourceFile) {
|
|
return typeof hostSourceFile === "boolean";
|
|
}
|
|
function isFilePresenceUnknownOnHost(hostSourceFile) {
|
|
return typeof hostSourceFile.version === "boolean";
|
|
}
|
|
function fileExists(fileName) {
|
|
const path = toPath3(fileName);
|
|
if (isFileMissingOnHost(sourceFilesCache.get(path))) {
|
|
return false;
|
|
}
|
|
return directoryStructureHost.fileExists(fileName);
|
|
}
|
|
function getVersionedSourceFileByPath(fileName, path, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
if (isFileMissingOnHost(hostSourceFile)) {
|
|
return void 0;
|
|
}
|
|
if (hostSourceFile === void 0 || shouldCreateNewSourceFile || isFilePresenceUnknownOnHost(hostSourceFile)) {
|
|
const sourceFile = getNewSourceFile(fileName, languageVersionOrOptions, onError);
|
|
if (hostSourceFile) {
|
|
if (sourceFile) {
|
|
hostSourceFile.sourceFile = sourceFile;
|
|
hostSourceFile.version = sourceFile.version;
|
|
if (!hostSourceFile.fileWatcher) {
|
|
hostSourceFile.fileWatcher = watchFilePath(path, fileName, onSourceFileChange, 250 /* Low */, watchOptions, WatchType.SourceFile);
|
|
}
|
|
} else {
|
|
if (hostSourceFile.fileWatcher) {
|
|
hostSourceFile.fileWatcher.close();
|
|
}
|
|
sourceFilesCache.set(path, false);
|
|
}
|
|
} else {
|
|
if (sourceFile) {
|
|
const fileWatcher = watchFilePath(path, fileName, onSourceFileChange, 250 /* Low */, watchOptions, WatchType.SourceFile);
|
|
sourceFilesCache.set(path, { sourceFile, version: sourceFile.version, fileWatcher });
|
|
} else {
|
|
sourceFilesCache.set(path, false);
|
|
}
|
|
}
|
|
return sourceFile;
|
|
}
|
|
return hostSourceFile.sourceFile;
|
|
}
|
|
function nextSourceFileVersion(path) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
if (hostSourceFile !== void 0) {
|
|
if (isFileMissingOnHost(hostSourceFile)) {
|
|
sourceFilesCache.set(path, { version: false });
|
|
} else {
|
|
hostSourceFile.version = false;
|
|
}
|
|
}
|
|
}
|
|
function getSourceVersion(path) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
return !hostSourceFile || !hostSourceFile.version ? void 0 : hostSourceFile.version;
|
|
}
|
|
function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
|
|
const hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath);
|
|
if (hostSourceFileInfo !== void 0) {
|
|
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(createCompilerDiagnostic(message), newLine, compilerOptions || optionsToExtendForConfigFile);
|
|
}
|
|
}
|
|
function hasChangedAutomaticTypeDirectiveNames() {
|
|
return resolutionCache.hasChangedAutomaticTypeDirectiveNames();
|
|
}
|
|
function clearInvalidateResolutionsOfFailedLookupLocations() {
|
|
if (!timerToInvalidateFailedLookupResolutions)
|
|
return false;
|
|
host.clearTimeout(timerToInvalidateFailedLookupResolutions);
|
|
timerToInvalidateFailedLookupResolutions = void 0;
|
|
return true;
|
|
}
|
|
function scheduleInvalidateResolutionsOfFailedLookupLocations() {
|
|
if (!host.setTimeout || !host.clearTimeout) {
|
|
return resolutionCache.invalidateResolutionsOfFailedLookupLocations();
|
|
}
|
|
const pending = clearInvalidateResolutionsOfFailedLookupLocations();
|
|
writeLog(`Scheduling invalidateFailedLookup${pending ? ", Cancelled earlier one" : ""}`);
|
|
timerToInvalidateFailedLookupResolutions = host.setTimeout(invalidateResolutionsOfFailedLookup, 250);
|
|
}
|
|
function invalidateResolutionsOfFailedLookup() {
|
|
timerToInvalidateFailedLookupResolutions = void 0;
|
|
if (resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {
|
|
scheduleProgramUpdate();
|
|
}
|
|
}
|
|
function scheduleProgramUpdate() {
|
|
if (!host.setTimeout || !host.clearTimeout) {
|
|
return;
|
|
}
|
|
if (timerToUpdateProgram) {
|
|
host.clearTimeout(timerToUpdateProgram);
|
|
}
|
|
writeLog("Scheduling update");
|
|
timerToUpdateProgram = host.setTimeout(updateProgramWithWatchStatus, 250);
|
|
}
|
|
function scheduleProgramReload() {
|
|
Debug.assert(!!configFileName);
|
|
reloadLevel = 2 /* Full */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateProgramWithWatchStatus() {
|
|
timerToUpdateProgram = void 0;
|
|
reportFileChangeDetectedOnCreateProgram = true;
|
|
updateProgram();
|
|
}
|
|
function updateProgram() {
|
|
switch (reloadLevel) {
|
|
case 1 /* Partial */:
|
|
perfLogger.logStartUpdateProgram("PartialConfigReload");
|
|
reloadFileNamesFromConfigFile();
|
|
break;
|
|
case 2 /* Full */:
|
|
perfLogger.logStartUpdateProgram("FullConfigReload");
|
|
reloadConfigFile();
|
|
break;
|
|
default:
|
|
perfLogger.logStartUpdateProgram("SynchronizeProgram");
|
|
synchronizeProgram();
|
|
break;
|
|
}
|
|
perfLogger.logStopUpdateProgram("Done");
|
|
return getCurrentBuilderProgram();
|
|
}
|
|
function reloadFileNamesFromConfigFile() {
|
|
writeLog("Reloading new file names and options");
|
|
reloadLevel = 0 /* None */;
|
|
rootFileNames = getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
|
|
if (updateErrorForNoInputFiles(rootFileNames, getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
|
|
hasChangedConfigFileParsingErrors = true;
|
|
}
|
|
synchronizeProgram();
|
|
}
|
|
function reloadConfigFile() {
|
|
writeLog(`Reloading config file: ${configFileName}`);
|
|
reloadLevel = 0 /* None */;
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.clearCache();
|
|
}
|
|
parseConfigFile2();
|
|
hasChangedCompilerOptions = true;
|
|
synchronizeProgram();
|
|
watchConfigFileWildCardDirectories();
|
|
updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
|
|
}
|
|
function parseConfigFile2() {
|
|
setConfigFileParsingResult(getParsedCommandLineOfConfigFile(
|
|
configFileName,
|
|
optionsToExtendForConfigFile,
|
|
parseConfigFileHost,
|
|
extendedConfigCache || (extendedConfigCache = /* @__PURE__ */ new Map()),
|
|
watchOptionsToExtend,
|
|
extraFileExtensions
|
|
));
|
|
}
|
|
function setConfigFileParsingResult(configFileParseResult) {
|
|
rootFileNames = configFileParseResult.fileNames;
|
|
compilerOptions = configFileParseResult.options;
|
|
watchOptions = configFileParseResult.watchOptions;
|
|
projectReferences = configFileParseResult.projectReferences;
|
|
wildcardDirectories = configFileParseResult.wildcardDirectories;
|
|
configFileParsingDiagnostics = getConfigFileParsingDiagnostics(configFileParseResult).slice();
|
|
canConfigFileJsonReportNoInputFiles = canJsonReportNoInputFiles(configFileParseResult.raw);
|
|
hasChangedConfigFileParsingErrors = true;
|
|
}
|
|
function getParsedCommandLine(configFileName2) {
|
|
const configPath = toPath3(configFileName2);
|
|
let config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (config) {
|
|
if (!config.reloadLevel)
|
|
return config.parsedCommandLine;
|
|
if (config.parsedCommandLine && config.reloadLevel === 1 /* Partial */ && !host.getParsedCommandLine) {
|
|
writeLog("Reloading new file names and options");
|
|
const fileNames = getFileNamesFromConfigSpecs(
|
|
config.parsedCommandLine.options.configFile.configFileSpecs,
|
|
getNormalizedAbsolutePath(getDirectoryPath(configFileName2), currentDirectory),
|
|
compilerOptions,
|
|
parseConfigFileHost
|
|
);
|
|
config.parsedCommandLine = { ...config.parsedCommandLine, fileNames };
|
|
config.reloadLevel = void 0;
|
|
return config.parsedCommandLine;
|
|
}
|
|
}
|
|
writeLog(`Loading config file: ${configFileName2}`);
|
|
const parsedCommandLine = host.getParsedCommandLine ? host.getParsedCommandLine(configFileName2) : getParsedCommandLineFromConfigFileHost(configFileName2);
|
|
if (config) {
|
|
config.parsedCommandLine = parsedCommandLine;
|
|
config.reloadLevel = void 0;
|
|
} else {
|
|
(parsedConfigs || (parsedConfigs = /* @__PURE__ */ new Map())).set(configPath, config = { parsedCommandLine });
|
|
}
|
|
watchReferencedProject(configFileName2, configPath, config);
|
|
return parsedCommandLine;
|
|
}
|
|
function getParsedCommandLineFromConfigFileHost(configFileName2) {
|
|
const onUnRecoverableConfigFileDiagnostic = parseConfigFileHost.onUnRecoverableConfigFileDiagnostic;
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = noop;
|
|
const parsedCommandLine = getParsedCommandLineOfConfigFile(
|
|
configFileName2,
|
|
void 0,
|
|
parseConfigFileHost,
|
|
extendedConfigCache || (extendedConfigCache = /* @__PURE__ */ new Map()),
|
|
watchOptionsToExtend
|
|
);
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = onUnRecoverableConfigFileDiagnostic;
|
|
return parsedCommandLine;
|
|
}
|
|
function onReleaseParsedCommandLine(fileName) {
|
|
var _a2;
|
|
const path = toPath3(fileName);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path);
|
|
if (!config)
|
|
return;
|
|
parsedConfigs.delete(path);
|
|
if (config.watchedDirectories)
|
|
clearMap(config.watchedDirectories, closeFileWatcherOf);
|
|
(_a2 = config.watcher) == null ? void 0 : _a2.close();
|
|
clearSharedExtendedConfigFileWatcher(path, sharedExtendedConfigFileWatchers);
|
|
}
|
|
function watchFilePath(path, file, callback, pollingInterval, options, watchType) {
|
|
return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path), pollingInterval, options, watchType);
|
|
}
|
|
function onSourceFileChange(fileName, eventKind, path) {
|
|
updateCachedSystemWithFile(fileName, path, eventKind);
|
|
if (eventKind === 2 /* Deleted */ && sourceFilesCache.has(path)) {
|
|
resolutionCache.invalidateResolutionOfFile(path);
|
|
}
|
|
nextSourceFileVersion(path);
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateCachedSystemWithFile(fileName, path, eventKind) {
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind);
|
|
}
|
|
}
|
|
function watchMissingFilePath(missingFilePath) {
|
|
return (parsedConfigs == null ? void 0 : parsedConfigs.has(missingFilePath)) ? noopFileWatcher : watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, 500 /* Medium */, watchOptions, WatchType.MissingFile);
|
|
}
|
|
function onMissingFileChange(fileName, eventKind, missingFilePath) {
|
|
updateCachedSystemWithFile(fileName, missingFilePath, eventKind);
|
|
if (eventKind === 0 /* Created */ && missingFilesMap.has(missingFilePath)) {
|
|
missingFilesMap.get(missingFilePath).close();
|
|
missingFilesMap.delete(missingFilePath);
|
|
nextSourceFileVersion(missingFilePath);
|
|
scheduleProgramUpdate();
|
|
}
|
|
}
|
|
function watchConfigFileWildCardDirectories() {
|
|
if (wildcardDirectories) {
|
|
updateWatchingWildcardDirectories(
|
|
watchedWildcardDirectories || (watchedWildcardDirectories = /* @__PURE__ */ new Map()),
|
|
new Map(getEntries(wildcardDirectories)),
|
|
watchWildcardDirectory
|
|
);
|
|
} else if (watchedWildcardDirectories) {
|
|
clearMap(watchedWildcardDirectories, closeFileWatcherOf);
|
|
}
|
|
}
|
|
function watchWildcardDirectory(directory, flags) {
|
|
return watchDirectory(
|
|
directory,
|
|
(fileOrDirectory) => {
|
|
Debug.assert(!!configFileName);
|
|
const fileOrDirectoryPath = toPath3(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
nextSourceFileVersion(fileOrDirectoryPath);
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath3(directory),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName,
|
|
extraFileExtensions,
|
|
options: compilerOptions,
|
|
program: getCurrentBuilderProgram() || rootFileNames,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}))
|
|
return;
|
|
if (reloadLevel !== 2 /* Full */) {
|
|
reloadLevel = 1 /* Partial */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
},
|
|
flags,
|
|
watchOptions,
|
|
WatchType.WildcardDirectory
|
|
);
|
|
}
|
|
function updateExtendedConfigFilesWatches(forProjectPath, options, watchOptions2, watchType) {
|
|
updateSharedExtendedConfigFileWatcher(
|
|
forProjectPath,
|
|
options,
|
|
sharedExtendedConfigFileWatchers || (sharedExtendedConfigFileWatchers = /* @__PURE__ */ new Map()),
|
|
(extendedConfigFileName, extendedConfigFilePath) => watchFile2(
|
|
extendedConfigFileName,
|
|
(_fileName, eventKind) => {
|
|
var _a2;
|
|
updateCachedSystemWithFile(extendedConfigFileName, extendedConfigFilePath, eventKind);
|
|
if (extendedConfigCache)
|
|
cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath3);
|
|
const projects = (_a2 = sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a2.projects;
|
|
if (!(projects == null ? void 0 : projects.size))
|
|
return;
|
|
projects.forEach((projectPath) => {
|
|
if (toPath3(configFileName) === projectPath) {
|
|
reloadLevel = 2 /* Full */;
|
|
} else {
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(projectPath);
|
|
if (config)
|
|
config.reloadLevel = 2 /* Full */;
|
|
resolutionCache.removeResolutionsFromProjectReferenceRedirects(projectPath);
|
|
}
|
|
scheduleProgramUpdate();
|
|
});
|
|
},
|
|
2e3 /* High */,
|
|
watchOptions2,
|
|
watchType
|
|
),
|
|
toPath3
|
|
);
|
|
}
|
|
function watchReferencedProject(configFileName2, configPath, commandLine) {
|
|
var _a2, _b, _c, _d, _e;
|
|
commandLine.watcher || (commandLine.watcher = watchFile2(
|
|
configFileName2,
|
|
(_fileName, eventKind) => {
|
|
updateCachedSystemWithFile(configFileName2, configPath, eventKind);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (config)
|
|
config.reloadLevel = 2 /* Full */;
|
|
resolutionCache.removeResolutionsFromProjectReferenceRedirects(configPath);
|
|
scheduleProgramUpdate();
|
|
},
|
|
2e3 /* High */,
|
|
((_a2 = commandLine.parsedCommandLine) == null ? void 0 : _a2.watchOptions) || watchOptions,
|
|
WatchType.ConfigFileOfReferencedProject
|
|
));
|
|
if ((_b = commandLine.parsedCommandLine) == null ? void 0 : _b.wildcardDirectories) {
|
|
updateWatchingWildcardDirectories(
|
|
commandLine.watchedDirectories || (commandLine.watchedDirectories = /* @__PURE__ */ new Map()),
|
|
new Map(getEntries((_c = commandLine.parsedCommandLine) == null ? void 0 : _c.wildcardDirectories)),
|
|
(directory, flags) => {
|
|
var _a3;
|
|
return watchDirectory(
|
|
directory,
|
|
(fileOrDirectory) => {
|
|
const fileOrDirectoryPath = toPath3(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
nextSourceFileVersion(fileOrDirectoryPath);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (!(config == null ? void 0 : config.parsedCommandLine))
|
|
return;
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath3(directory),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName: configFileName2,
|
|
options: config.parsedCommandLine.options,
|
|
program: config.parsedCommandLine.fileNames,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}))
|
|
return;
|
|
if (config.reloadLevel !== 2 /* Full */) {
|
|
config.reloadLevel = 1 /* Partial */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
},
|
|
flags,
|
|
((_a3 = commandLine.parsedCommandLine) == null ? void 0 : _a3.watchOptions) || watchOptions,
|
|
WatchType.WildcardDirectoryOfReferencedProject
|
|
);
|
|
}
|
|
);
|
|
} else if (commandLine.watchedDirectories) {
|
|
clearMap(commandLine.watchedDirectories, closeFileWatcherOf);
|
|
commandLine.watchedDirectories = void 0;
|
|
}
|
|
updateExtendedConfigFilesWatches(
|
|
configPath,
|
|
(_d = commandLine.parsedCommandLine) == null ? void 0 : _d.options,
|
|
((_e = commandLine.parsedCommandLine) == null ? void 0 : _e.watchOptions) || watchOptions,
|
|
WatchType.ExtendedConfigOfReferencedProject
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/tsbuild.ts
|
|
function resolveConfigFileProjectName(project) {
|
|
if (fileExtensionIs(project, ".json" /* Json */)) {
|
|
return project;
|
|
}
|
|
return combinePaths(project, "tsconfig.json");
|
|
}
|
|
|
|
// src/compiler/tsbuildPublic.ts
|
|
var minimumDate = new Date(-864e13);
|
|
var maximumDate = new Date(864e13);
|
|
function getOrCreateValueFromConfigFileMap(configFileMap, resolved, createT) {
|
|
const existingValue = configFileMap.get(resolved);
|
|
let newValue;
|
|
if (!existingValue) {
|
|
newValue = createT();
|
|
configFileMap.set(resolved, newValue);
|
|
}
|
|
return existingValue || newValue;
|
|
}
|
|
function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) {
|
|
return getOrCreateValueFromConfigFileMap(configFileMap, resolved, () => /* @__PURE__ */ new Map());
|
|
}
|
|
function getCurrentTime(host) {
|
|
return host.now ? host.now() : new Date();
|
|
}
|
|
function isCircularBuildOrder(buildOrder) {
|
|
return !!buildOrder && !!buildOrder.buildOrder;
|
|
}
|
|
function getBuildOrderFromAnyBuildOrder(anyBuildOrder) {
|
|
return isCircularBuildOrder(anyBuildOrder) ? anyBuildOrder.buildOrder : anyBuildOrder;
|
|
}
|
|
function createBuilderStatusReporter(system, pretty) {
|
|
return (diagnostic) => {
|
|
let output = pretty ? `[${formatColorAndReset(getLocaleTimeString(system), "\x1B[90m" /* Grey */)}] ` : `${getLocaleTimeString(system)} - `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${system.newLine + system.newLine}`;
|
|
system.write(output);
|
|
};
|
|
}
|
|
function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
|
|
const host = createProgramHost(system, createProgram2);
|
|
host.getModifiedTime = system.getModifiedTime ? (path) => system.getModifiedTime(path) : returnUndefined;
|
|
host.setModifiedTime = system.setModifiedTime ? (path, date) => system.setModifiedTime(path, date) : noop;
|
|
host.deleteFile = system.deleteFile ? (path) => system.deleteFile(path) : noop;
|
|
host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
|
|
host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
|
|
host.now = maybeBind(system, system.now);
|
|
return host;
|
|
}
|
|
function createSolutionBuilderHost(system = sys, createProgram2, reportDiagnostic, reportSolutionBuilderStatus, reportErrorSummary2) {
|
|
const host = createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus);
|
|
host.reportErrorSummary = reportErrorSummary2;
|
|
return host;
|
|
}
|
|
function createSolutionBuilderWithWatchHost(system = sys, createProgram2, reportDiagnostic, reportSolutionBuilderStatus, reportWatchStatus2) {
|
|
const host = createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus);
|
|
const watchHost = createWatchHost(system, reportWatchStatus2);
|
|
copyProperties(host, watchHost);
|
|
return host;
|
|
}
|
|
function getCompilerOptionsOfBuildOptions(buildOptions) {
|
|
const result = {};
|
|
commonOptionsWithBuild.forEach((option) => {
|
|
if (hasProperty(buildOptions, option.name))
|
|
result[option.name] = buildOptions[option.name];
|
|
});
|
|
return result;
|
|
}
|
|
function createSolutionBuilder(host, rootNames, defaultOptions) {
|
|
return createSolutionBuilderWorker(false, host, rootNames, defaultOptions);
|
|
}
|
|
function createSolutionBuilderWithWatch(host, rootNames, defaultOptions, baseWatchOptions) {
|
|
return createSolutionBuilderWorker(true, host, rootNames, defaultOptions, baseWatchOptions);
|
|
}
|
|
function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) {
|
|
const host = hostOrHostWithWatch;
|
|
const hostWithWatch = hostOrHostWithWatch;
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
const baseCompilerOptions = getCompilerOptionsOfBuildOptions(options);
|
|
const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);
|
|
setGetSourceFileAsHashVersioned(compilerHost, host);
|
|
compilerHost.getParsedCommandLine = (fileName) => parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName));
|
|
compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
|
|
compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
|
|
compilerHost.getModuleResolutionCache = maybeBind(host, host.getModuleResolutionCache);
|
|
const moduleResolutionCache = !compilerHost.resolveModuleNames ? createModuleResolutionCache(currentDirectory, getCanonicalFileName) : void 0;
|
|
const typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : void 0;
|
|
if (!compilerHost.resolveModuleNames) {
|
|
const loader = (moduleName, resolverMode, containingFile, redirectedReference) => resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
|
|
compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) => loadWithModeAwareCache(Debug.checkEachDefined(moduleNames), Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, resolutionInfo, loader);
|
|
compilerHost.getModuleResolutionCache = () => moduleResolutionCache;
|
|
}
|
|
if (!compilerHost.resolveTypeReferenceDirectives) {
|
|
const loader = (moduleName, containingFile, redirectedReference, containingFileMode) => resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective;
|
|
compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
|
|
}
|
|
compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo3(state, fileName, toResolvedConfigFilePath(state, configFilePath), void 0);
|
|
const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(hostWithWatch, options);
|
|
const state = {
|
|
host,
|
|
hostWithWatch,
|
|
currentDirectory,
|
|
getCanonicalFileName,
|
|
parseConfigFileHost: parseConfigHostFromCompilerHostLike(host),
|
|
write: maybeBind(host, host.trace),
|
|
options,
|
|
baseCompilerOptions,
|
|
rootNames,
|
|
baseWatchOptions,
|
|
resolvedConfigFilePaths: /* @__PURE__ */ new Map(),
|
|
configFileCache: /* @__PURE__ */ new Map(),
|
|
projectStatus: /* @__PURE__ */ new Map(),
|
|
extendedConfigCache: /* @__PURE__ */ new Map(),
|
|
buildInfoCache: /* @__PURE__ */ new Map(),
|
|
outputTimeStamps: /* @__PURE__ */ new Map(),
|
|
builderPrograms: /* @__PURE__ */ new Map(),
|
|
diagnostics: /* @__PURE__ */ new Map(),
|
|
projectPendingBuild: /* @__PURE__ */ new Map(),
|
|
projectErrorsReported: /* @__PURE__ */ new Map(),
|
|
compilerHost,
|
|
moduleResolutionCache,
|
|
typeReferenceDirectiveResolutionCache,
|
|
buildOrder: void 0,
|
|
readFileWithCache: (f) => host.readFile(f),
|
|
projectCompilerOptions: baseCompilerOptions,
|
|
cache: void 0,
|
|
allProjectBuildPending: true,
|
|
needsSummary: true,
|
|
watchAllProjectsPending: watch,
|
|
watch,
|
|
allWatchedWildcardDirectories: /* @__PURE__ */ new Map(),
|
|
allWatchedInputFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedConfigFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedExtendedConfigFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedPackageJsonFiles: /* @__PURE__ */ new Map(),
|
|
filesWatched: /* @__PURE__ */ new Map(),
|
|
lastCachedPackageJsonLookups: /* @__PURE__ */ new Map(),
|
|
timerToBuildInvalidatedProject: void 0,
|
|
reportFileChangeDetected: false,
|
|
watchFile: watchFile2,
|
|
watchDirectory,
|
|
writeLog
|
|
};
|
|
return state;
|
|
}
|
|
function toPath2(state, fileName) {
|
|
return toPath(fileName, state.currentDirectory, state.getCanonicalFileName);
|
|
}
|
|
function toResolvedConfigFilePath(state, fileName) {
|
|
const { resolvedConfigFilePaths } = state;
|
|
const path = resolvedConfigFilePaths.get(fileName);
|
|
if (path !== void 0)
|
|
return path;
|
|
const resolvedPath = toPath2(state, fileName);
|
|
resolvedConfigFilePaths.set(fileName, resolvedPath);
|
|
return resolvedPath;
|
|
}
|
|
function isParsedCommandLine(entry) {
|
|
return !!entry.options;
|
|
}
|
|
function getCachedParsedConfigFile(state, configFilePath) {
|
|
const value = state.configFileCache.get(configFilePath);
|
|
return value && isParsedCommandLine(value) ? value : void 0;
|
|
}
|
|
function parseConfigFile(state, configFileName, configFilePath) {
|
|
const { configFileCache } = state;
|
|
const value = configFileCache.get(configFilePath);
|
|
if (value) {
|
|
return isParsedCommandLine(value) ? value : void 0;
|
|
}
|
|
mark("SolutionBuilder::beforeConfigFileParsing");
|
|
let diagnostic;
|
|
const { parseConfigFileHost, baseCompilerOptions, baseWatchOptions, extendedConfigCache, host } = state;
|
|
let parsed;
|
|
if (host.getParsedCommandLine) {
|
|
parsed = host.getParsedCommandLine(configFileName);
|
|
if (!parsed)
|
|
diagnostic = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);
|
|
} else {
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = (d) => diagnostic = d;
|
|
parsed = getParsedCommandLineOfConfigFile(configFileName, baseCompilerOptions, parseConfigFileHost, extendedConfigCache, baseWatchOptions);
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = noop;
|
|
}
|
|
configFileCache.set(configFilePath, parsed || diagnostic);
|
|
mark("SolutionBuilder::afterConfigFileParsing");
|
|
measure("SolutionBuilder::Config file parsing", "SolutionBuilder::beforeConfigFileParsing", "SolutionBuilder::afterConfigFileParsing");
|
|
return parsed;
|
|
}
|
|
function resolveProjectName(state, name) {
|
|
return resolveConfigFileProjectName(resolvePath(state.currentDirectory, name));
|
|
}
|
|
function createBuildOrder(state, roots) {
|
|
const temporaryMarks = /* @__PURE__ */ new Map();
|
|
const permanentMarks = /* @__PURE__ */ new Map();
|
|
const circularityReportStack = [];
|
|
let buildOrder;
|
|
let circularDiagnostics;
|
|
for (const root of roots) {
|
|
visit(root);
|
|
}
|
|
return circularDiagnostics ? { buildOrder: buildOrder || emptyArray, circularDiagnostics } : buildOrder || emptyArray;
|
|
function visit(configFileName, inCircularContext) {
|
|
const projPath = toResolvedConfigFilePath(state, configFileName);
|
|
if (permanentMarks.has(projPath))
|
|
return;
|
|
if (temporaryMarks.has(projPath)) {
|
|
if (!inCircularContext) {
|
|
(circularDiagnostics || (circularDiagnostics = [])).push(
|
|
createCompilerDiagnostic(
|
|
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);
|
|
const parsed = parseConfigFile(state, configFileName, projPath);
|
|
if (parsed && parsed.projectReferences) {
|
|
for (const ref of parsed.projectReferences) {
|
|
const 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) {
|
|
const buildOrder = createBuildOrder(state, state.rootNames.map((f) => resolveProjectName(state, f)));
|
|
state.resolvedConfigFilePaths.clear();
|
|
const currentProjects = new Map(
|
|
getBuildOrderFromAnyBuildOrder(buildOrder).map(
|
|
(resolved) => [toResolvedConfigFilePath(state, resolved), true]
|
|
)
|
|
);
|
|
const noopOnDelete = { onDeleteValue: noop };
|
|
mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete);
|
|
if (state.watch) {
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedConfigFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: closeFileWatcher }
|
|
);
|
|
state.allWatchedExtendedConfigFiles.forEach((watcher) => {
|
|
watcher.projects.forEach((project) => {
|
|
if (!currentProjects.has(project)) {
|
|
watcher.projects.delete(project);
|
|
}
|
|
});
|
|
watcher.close();
|
|
});
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedWildcardDirectories,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcherOf) }
|
|
);
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedInputFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcher) }
|
|
);
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedPackageJsonFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcher) }
|
|
);
|
|
}
|
|
return state.buildOrder = buildOrder;
|
|
}
|
|
function getBuildOrderFor(state, project, onlyReferences) {
|
|
const resolvedProject = project && resolveProjectName(state, project);
|
|
const buildOrderFromState = getBuildOrder(state);
|
|
if (isCircularBuildOrder(buildOrderFromState))
|
|
return buildOrderFromState;
|
|
if (resolvedProject) {
|
|
const projectPath = toResolvedConfigFilePath(state, resolvedProject);
|
|
const projectIndex = findIndex(
|
|
buildOrderFromState,
|
|
(configFileName) => toResolvedConfigFilePath(state, configFileName) === projectPath
|
|
);
|
|
if (projectIndex === -1)
|
|
return void 0;
|
|
}
|
|
const buildOrder = resolvedProject ? createBuildOrder(state, [resolvedProject]) : buildOrderFromState;
|
|
Debug.assert(!isCircularBuildOrder(buildOrder));
|
|
Debug.assert(!onlyReferences || resolvedProject !== void 0);
|
|
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);
|
|
}
|
|
const { compilerHost, host } = state;
|
|
const originalReadFileWithCache = state.readFileWithCache;
|
|
const originalGetSourceFile = compilerHost.getSourceFile;
|
|
const {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
getSourceFileWithCache,
|
|
readFileWithCache
|
|
} = changeCompilerHostLikeToUseCache(
|
|
host,
|
|
(fileName) => toPath2(state, fileName),
|
|
(...args) => originalGetSourceFile.call(compilerHost, ...args)
|
|
);
|
|
state.readFileWithCache = readFileWithCache;
|
|
compilerHost.getSourceFile = getSourceFileWithCache;
|
|
state.cache = {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
originalReadFileWithCache,
|
|
originalGetSourceFile
|
|
};
|
|
}
|
|
function disableCache(state) {
|
|
if (!state.cache)
|
|
return;
|
|
const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache } = state;
|
|
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 ? void 0 : moduleResolutionCache.clear();
|
|
typeReferenceDirectiveResolutionCache == null ? void 0 : typeReferenceDirectiveResolutionCache.clear();
|
|
state.cache = void 0;
|
|
}
|
|
function clearProjectStatus(state, resolved) {
|
|
state.projectStatus.delete(resolved);
|
|
state.diagnostics.delete(resolved);
|
|
}
|
|
function addProjToQueue({ projectPendingBuild }, proj, reloadLevel) {
|
|
const value = projectPendingBuild.get(proj);
|
|
if (value === void 0) {
|
|
projectPendingBuild.set(proj, reloadLevel);
|
|
} else if (value < reloadLevel) {
|
|
projectPendingBuild.set(proj, reloadLevel);
|
|
}
|
|
}
|
|
function setupInitialBuild(state, cancellationToken) {
|
|
if (!state.allProjectBuildPending)
|
|
return;
|
|
state.allProjectBuildPending = false;
|
|
if (state.options.watch)
|
|
reportWatchStatus(state, Diagnostics.Starting_compilation_in_watch_mode);
|
|
enableCache(state);
|
|
const buildOrder = getBuildOrderFromAnyBuildOrder(getBuildOrder(state));
|
|
buildOrder.forEach(
|
|
(configFileName) => state.projectPendingBuild.set(
|
|
toResolvedConfigFilePath(state, configFileName),
|
|
0 /* None */
|
|
)
|
|
);
|
|
if (cancellationToken) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
function doneInvalidatedProject(state, projectPath) {
|
|
state.projectPendingBuild.delete(projectPath);
|
|
return state.diagnostics.has(projectPath) ? 1 /* DiagnosticsPresent_OutputsSkipped */ : 0 /* Success */;
|
|
}
|
|
function createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder) {
|
|
let updateOutputFileStampsPending = true;
|
|
return {
|
|
kind: 2 /* UpdateOutputFileStamps */,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
updateOutputFileStatmps: () => {
|
|
updateOutputTimestamps(state, config, projectPath);
|
|
updateOutputFileStampsPending = false;
|
|
},
|
|
done: () => {
|
|
if (updateOutputFileStampsPending) {
|
|
updateOutputTimestamps(state, config, projectPath);
|
|
}
|
|
mark("SolutionBuilder::Timestamps only updates");
|
|
return doneInvalidatedProject(state, projectPath);
|
|
}
|
|
};
|
|
}
|
|
function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath, projectIndex, config, buildOrder) {
|
|
let step = kind === 0 /* Build */ ? 0 /* CreateProgram */ : 4 /* EmitBundle */;
|
|
let program;
|
|
let buildResult;
|
|
let invalidatedProjectOfBundle;
|
|
return kind === 0 /* Build */ ? {
|
|
kind,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
getBuilderProgram: () => withProgramOrUndefined(identity),
|
|
getProgram: () => withProgramOrUndefined(
|
|
(program2) => program2.getProgramOrUndefined()
|
|
),
|
|
getSourceFile: (fileName) => withProgramOrUndefined(
|
|
(program2) => program2.getSourceFile(fileName)
|
|
),
|
|
getSourceFiles: () => withProgramOrEmptyArray(
|
|
(program2) => program2.getSourceFiles()
|
|
),
|
|
getOptionsDiagnostics: (cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getOptionsDiagnostics(cancellationToken)
|
|
),
|
|
getGlobalDiagnostics: (cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getGlobalDiagnostics(cancellationToken)
|
|
),
|
|
getConfigFileParsingDiagnostics: () => withProgramOrEmptyArray(
|
|
(program2) => program2.getConfigFileParsingDiagnostics()
|
|
),
|
|
getSyntacticDiagnostics: (sourceFile, cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getSyntacticDiagnostics(sourceFile, cancellationToken)
|
|
),
|
|
getAllDependencies: (sourceFile) => withProgramOrEmptyArray(
|
|
(program2) => program2.getAllDependencies(sourceFile)
|
|
),
|
|
getSemanticDiagnostics: (sourceFile, cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getSemanticDiagnostics(sourceFile, cancellationToken)
|
|
),
|
|
getSemanticDiagnosticsOfNextAffectedFile: (cancellationToken, ignoreSourceFile) => withProgramOrUndefined(
|
|
(program2) => program2.getSemanticDiagnosticsOfNextAffectedFile && program2.getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile)
|
|
),
|
|
emit: (targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
|
|
if (targetSourceFile || emitOnlyDtsFiles) {
|
|
return withProgramOrUndefined(
|
|
(program2) => {
|
|
var _a2, _b;
|
|
return program2.emit(targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project)));
|
|
}
|
|
);
|
|
}
|
|
executeSteps(2 /* SemanticDiagnostics */, cancellationToken);
|
|
if (step === 5 /* EmitBuildInfo */) {
|
|
return emitBuildInfo(writeFile2, cancellationToken);
|
|
}
|
|
if (step !== 3 /* Emit */)
|
|
return void 0;
|
|
return emit(writeFile2, cancellationToken, customTransformers);
|
|
},
|
|
done
|
|
} : {
|
|
kind,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
emit: (writeFile2, customTransformers) => {
|
|
if (step !== 4 /* EmitBundle */)
|
|
return invalidatedProjectOfBundle;
|
|
return emitBundle(writeFile2, customTransformers);
|
|
},
|
|
done
|
|
};
|
|
function done(cancellationToken, writeFile2, customTransformers) {
|
|
executeSteps(8 /* Done */, cancellationToken, writeFile2, customTransformers);
|
|
if (kind === 0 /* Build */)
|
|
mark("SolutionBuilder::Projects built");
|
|
else
|
|
mark("SolutionBuilder::Bundles updated");
|
|
return doneInvalidatedProject(state, projectPath);
|
|
}
|
|
function withProgramOrUndefined(action) {
|
|
executeSteps(0 /* CreateProgram */);
|
|
return program && action(program);
|
|
}
|
|
function withProgramOrEmptyArray(action) {
|
|
return withProgramOrUndefined(action) || emptyArray;
|
|
}
|
|
function createProgram2() {
|
|
var _a2, _b;
|
|
Debug.assert(program === void 0);
|
|
if (state.options.dry) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_build_project_0, project);
|
|
buildResult = 1 /* Success */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return;
|
|
}
|
|
if (state.options.verbose)
|
|
reportStatus(state, Diagnostics.Building_project_0, project);
|
|
if (config.fileNames.length === 0) {
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
buildResult = 0 /* None */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return;
|
|
}
|
|
const { host, compilerHost } = state;
|
|
state.projectCompilerOptions = config.options;
|
|
(_a2 = state.moduleResolutionCache) == null ? void 0 : _a2.update(config.options);
|
|
(_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config.options);
|
|
program = host.createProgram(
|
|
config.fileNames,
|
|
config.options,
|
|
compilerHost,
|
|
getOldProgram(state, projectPath, config),
|
|
getConfigFileParsingDiagnostics(config),
|
|
config.projectReferences
|
|
);
|
|
if (state.watch) {
|
|
state.lastCachedPackageJsonLookups.set(projectPath, state.moduleResolutionCache && map(
|
|
state.moduleResolutionCache.getPackageJsonInfoCache().entries(),
|
|
([path, data]) => [state.host.realpath && data ? toPath2(state, state.host.realpath(path)) : path, data]
|
|
));
|
|
state.builderPrograms.set(projectPath, program);
|
|
}
|
|
step++;
|
|
}
|
|
function handleDiagnostics(diagnostics, errorFlags, errorType) {
|
|
if (diagnostics.length) {
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
diagnostics,
|
|
errorFlags,
|
|
errorType
|
|
));
|
|
} else {
|
|
step++;
|
|
}
|
|
}
|
|
function getSyntaxDiagnostics(cancellationToken) {
|
|
Debug.assertIsDefined(program);
|
|
handleDiagnostics(
|
|
[
|
|
...program.getConfigFileParsingDiagnostics(),
|
|
...program.getOptionsDiagnostics(cancellationToken),
|
|
...program.getGlobalDiagnostics(cancellationToken),
|
|
...program.getSyntacticDiagnostics(void 0, cancellationToken)
|
|
],
|
|
8 /* SyntaxErrors */,
|
|
"Syntactic"
|
|
);
|
|
}
|
|
function getSemanticDiagnostics(cancellationToken) {
|
|
handleDiagnostics(
|
|
Debug.checkDefined(program).getSemanticDiagnostics(void 0, cancellationToken),
|
|
16 /* TypeErrors */,
|
|
"Semantic"
|
|
);
|
|
}
|
|
function emit(writeFileCallback, cancellationToken, customTransformers) {
|
|
var _a2, _b, _c;
|
|
Debug.assertIsDefined(program);
|
|
Debug.assert(step === 3 /* Emit */);
|
|
const saved = program.saveEmitState();
|
|
let declDiagnostics;
|
|
const reportDeclarationDiagnostics = (d) => (declDiagnostics || (declDiagnostics = [])).push(d);
|
|
const outputFiles = [];
|
|
const { emitResult } = emitFilesAndReportErrors(
|
|
program,
|
|
reportDeclarationDiagnostics,
|
|
void 0,
|
|
void 0,
|
|
(name, text, writeByteOrderMark, _onError, _sourceFiles, data) => outputFiles.push({ name, text, writeByteOrderMark, data }),
|
|
cancellationToken,
|
|
false,
|
|
customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project))
|
|
);
|
|
if (declDiagnostics) {
|
|
program.restoreEmitState(saved);
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
declDiagnostics,
|
|
32 /* DeclarationEmitErrors */,
|
|
"Declaration file"
|
|
));
|
|
return {
|
|
emitSkipped: true,
|
|
diagnostics: emitResult.diagnostics
|
|
};
|
|
}
|
|
const { host, compilerHost } = state;
|
|
const resultFlags = ((_c = program.hasChangedEmitSignature) == null ? void 0 : _c.call(program)) ? 0 /* None */ : 2 /* DeclarationOutputUnchanged */;
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const emittedOutputs = /* @__PURE__ */ new Map();
|
|
const options = program.getCompilerOptions();
|
|
const isIncremental = isIncrementalCompilation(options);
|
|
let outputTimeStampMap;
|
|
let now;
|
|
outputFiles.forEach(({ name, text, writeByteOrderMark, data }) => {
|
|
const path = toPath2(state, name);
|
|
emittedOutputs.set(toPath2(state, name), name);
|
|
if (data == null ? void 0 : data.buildInfo)
|
|
setBuildInfo(state, data.buildInfo, projectPath, options, resultFlags);
|
|
const modifiedTime = (data == null ? void 0 : data.differsOnlyInMap) ? getModifiedTime(state.host, name) : void 0;
|
|
writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
|
|
if (data == null ? void 0 : data.differsOnlyInMap)
|
|
state.host.setModifiedTime(name, modifiedTime);
|
|
else if (!isIncremental && state.watch) {
|
|
(outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host)));
|
|
}
|
|
});
|
|
finishEmit(
|
|
emitterDiagnostics,
|
|
emittedOutputs,
|
|
outputFiles.length ? outputFiles[0].name : getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()),
|
|
resultFlags
|
|
);
|
|
return emitResult;
|
|
}
|
|
function emitBuildInfo(writeFileCallback, cancellationToken) {
|
|
Debug.assertIsDefined(program);
|
|
Debug.assert(step === 5 /* EmitBuildInfo */);
|
|
const emitResult = program.emitBuildInfo((name, text, writeByteOrderMark, onError, sourceFiles, data) => {
|
|
if (data == null ? void 0 : data.buildInfo)
|
|
setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions(), 2 /* 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, [...state.diagnostics.get(projectPath), ...emitResult.diagnostics]);
|
|
buildResult = 64 /* EmitErrors */ & buildResult;
|
|
}
|
|
if (emitResult.emittedFiles && state.write) {
|
|
emitResult.emittedFiles.forEach((name) => listEmittedFile(state, config, name));
|
|
}
|
|
afterProgramDone(state, program, config);
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return emitResult;
|
|
}
|
|
function finishEmit(emitterDiagnostics, emittedOutputs, oldestOutputFileName, resultFlags) {
|
|
const emitDiagnostics = emitterDiagnostics.getDiagnostics();
|
|
if (emitDiagnostics.length) {
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
emitDiagnostics,
|
|
64 /* EmitErrors */,
|
|
"Emit"
|
|
));
|
|
return emitDiagnostics;
|
|
}
|
|
if (state.write) {
|
|
emittedOutputs.forEach((name) => listEmittedFile(state, config, name));
|
|
}
|
|
updateOutputTimestampsWorker(state, config, projectPath, Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
|
|
state.diagnostics.delete(projectPath);
|
|
state.projectStatus.set(projectPath, {
|
|
type: 1 /* UpToDate */,
|
|
oldestOutputFileName
|
|
});
|
|
afterProgramDone(state, program, config);
|
|
step = 7 /* QueueReferencingProjects */;
|
|
buildResult = resultFlags;
|
|
return emitDiagnostics;
|
|
}
|
|
function emitBundle(writeFileCallback, customTransformers) {
|
|
var _a2, _b, _c, _d;
|
|
Debug.assert(kind === 1 /* UpdateBundle */);
|
|
if (state.options.dry) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
|
|
buildResult = 1 /* Success */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return void 0;
|
|
}
|
|
if (state.options.verbose)
|
|
reportStatus(state, Diagnostics.Updating_output_of_project_0, project);
|
|
const { compilerHost } = state;
|
|
state.projectCompilerOptions = config.options;
|
|
(_b = (_a2 = state.host).beforeEmitBundle) == null ? void 0 : _b.call(_a2, config);
|
|
const outputFiles = emitUsingBuildInfo(
|
|
config,
|
|
compilerHost,
|
|
(ref) => {
|
|
const refName = resolveProjectName(state, ref.path);
|
|
return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName));
|
|
},
|
|
customTransformers || ((_d = (_c = state.host).getCustomTransformers) == null ? void 0 : _d.call(_c, project))
|
|
);
|
|
if (isString(outputFiles)) {
|
|
reportStatus(state, Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
|
|
step = 6 /* BuildInvalidatedProjectOfBundle */;
|
|
return invalidatedProjectOfBundle = createBuildOrUpdateInvalidedProject(
|
|
0 /* Build */,
|
|
state,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config,
|
|
buildOrder
|
|
);
|
|
}
|
|
Debug.assert(!!outputFiles.length);
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const emittedOutputs = /* @__PURE__ */ new Map();
|
|
let resultFlags = 2 /* DeclarationOutputUnchanged */;
|
|
const existingBuildInfo = state.buildInfoCache.get(projectPath).buildInfo || void 0;
|
|
outputFiles.forEach(({ name, text, writeByteOrderMark, data }) => {
|
|
var _a3, _b2;
|
|
emittedOutputs.set(toPath2(state, name), name);
|
|
if (data == null ? void 0 : data.buildInfo) {
|
|
if (((_a3 = data.buildInfo.program) == null ? void 0 : _a3.outSignature) !== ((_b2 = existingBuildInfo == null ? void 0 : existingBuildInfo.program) == null ? void 0 : _b2.outSignature)) {
|
|
resultFlags &= ~2 /* DeclarationOutputUnchanged */;
|
|
}
|
|
setBuildInfo(state, data.buildInfo, projectPath, config.options, resultFlags);
|
|
}
|
|
writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
|
|
});
|
|
const emitDiagnostics = finishEmit(
|
|
emitterDiagnostics,
|
|
emittedOutputs,
|
|
outputFiles[0].name,
|
|
resultFlags
|
|
);
|
|
return { emitSkipped: false, diagnostics: emitDiagnostics };
|
|
}
|
|
function executeSteps(till, cancellationToken, writeFile2, customTransformers) {
|
|
while (step <= till && step < 8 /* Done */) {
|
|
const currentStep = step;
|
|
switch (step) {
|
|
case 0 /* CreateProgram */:
|
|
createProgram2();
|
|
break;
|
|
case 1 /* SyntaxDiagnostics */:
|
|
getSyntaxDiagnostics(cancellationToken);
|
|
break;
|
|
case 2 /* SemanticDiagnostics */:
|
|
getSemanticDiagnostics(cancellationToken);
|
|
break;
|
|
case 3 /* Emit */:
|
|
emit(writeFile2, cancellationToken, customTransformers);
|
|
break;
|
|
case 5 /* EmitBuildInfo */:
|
|
emitBuildInfo(writeFile2, cancellationToken);
|
|
break;
|
|
case 4 /* EmitBundle */:
|
|
emitBundle(writeFile2, customTransformers);
|
|
break;
|
|
case 6 /* BuildInvalidatedProjectOfBundle */:
|
|
Debug.checkDefined(invalidatedProjectOfBundle).done(cancellationToken, writeFile2, customTransformers);
|
|
step = 8 /* Done */;
|
|
break;
|
|
case 7 /* QueueReferencingProjects */:
|
|
queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
|
|
step++;
|
|
break;
|
|
case 8 /* Done */:
|
|
default:
|
|
assertType(step);
|
|
}
|
|
Debug.assert(step > currentStep);
|
|
}
|
|
}
|
|
}
|
|
function needsBuild({ options }, status, config) {
|
|
if (status.type !== 3 /* OutOfDateWithPrepend */ || options.force)
|
|
return true;
|
|
return config.fileNames.length === 0 || !!getConfigFileParsingDiagnostics(config).length || !isIncrementalCompilation(config.options);
|
|
}
|
|
function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
|
|
if (!state.projectPendingBuild.size)
|
|
return void 0;
|
|
if (isCircularBuildOrder(buildOrder))
|
|
return void 0;
|
|
const { options, projectPendingBuild } = state;
|
|
for (let projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
|
|
const project = buildOrder[projectIndex];
|
|
const projectPath = toResolvedConfigFilePath(state, project);
|
|
const reloadLevel = state.projectPendingBuild.get(projectPath);
|
|
if (reloadLevel === void 0)
|
|
continue;
|
|
if (reportQueue) {
|
|
reportQueue = false;
|
|
reportBuildQueue(state, buildOrder);
|
|
}
|
|
const config = parseConfigFile(state, project, projectPath);
|
|
if (!config) {
|
|
reportParseConfigFileDiagnostic(state, projectPath);
|
|
projectPendingBuild.delete(projectPath);
|
|
continue;
|
|
}
|
|
if (reloadLevel === 2 /* 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 === 1 /* Partial */) {
|
|
config.fileNames = getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, getDirectoryPath(project), config.options, state.parseConfigFileHost);
|
|
updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, canJsonReportNoInputFiles(config.raw));
|
|
watchInputFiles(state, project, projectPath, config);
|
|
watchPackageJsonFiles(state, project, projectPath, config);
|
|
}
|
|
const status = getUpToDateStatus(state, config, projectPath);
|
|
if (!options.force) {
|
|
if (status.type === 1 /* UpToDate */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
if (options.dry) {
|
|
reportStatus(state, Diagnostics.Project_0_is_up_to_date, project);
|
|
}
|
|
continue;
|
|
}
|
|
if (status.type === 2 /* UpToDateWithUpstreamTypes */ || status.type === 14 /* UpToDateWithInputFileText */) {
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
return {
|
|
kind: 2 /* UpdateOutputFileStamps */,
|
|
status,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config
|
|
};
|
|
}
|
|
}
|
|
if (status.type === 11 /* UpstreamBlocked */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
if (options.verbose) {
|
|
reportStatus(
|
|
state,
|
|
status.upstreamProjectBlocked ? Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_was_not_built : Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_has_errors,
|
|
project,
|
|
status.upstreamProjectName
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
if (status.type === 15 /* ContainerOnly */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
continue;
|
|
}
|
|
return {
|
|
kind: needsBuild(state, status, config) ? 0 /* Build */ : 1 /* UpdateBundle */,
|
|
status,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function createInvalidatedProjectWithInfo(state, info, buildOrder) {
|
|
verboseReportProjectStatus(state, info.project, info.status);
|
|
return info.kind !== 2 /* 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) {
|
|
const info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
|
|
if (!info)
|
|
return info;
|
|
return createInvalidatedProjectWithInfo(state, info, buildOrder);
|
|
}
|
|
function listEmittedFile({ write }, proj, file) {
|
|
if (write && proj.options.listEmittedFiles) {
|
|
write(`TSFILE: ${file}`);
|
|
}
|
|
}
|
|
function getOldProgram({ options, builderPrograms, compilerHost }, proj, parsed) {
|
|
if (options.force)
|
|
return void 0;
|
|
const value = builderPrograms.get(proj);
|
|
if (value)
|
|
return value;
|
|
return readBuilderProgram(parsed.options, compilerHost);
|
|
}
|
|
function afterProgramDone(state, program, config) {
|
|
if (program) {
|
|
if (state.write)
|
|
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) {
|
|
const canEmitBuildInfo = program && !outFile(program.getCompilerOptions());
|
|
reportAndStoreErrors(state, resolvedPath, diagnostics);
|
|
state.projectStatus.set(resolvedPath, { type: 0 /* Unbuildable */, reason: `${errorType} errors` });
|
|
if (canEmitBuildInfo)
|
|
return { buildResult, step: 5 /* EmitBuildInfo */ };
|
|
afterProgramDone(state, program, config);
|
|
return { buildResult, step: 7 /* QueueReferencingProjects */ };
|
|
}
|
|
function isFileWatcherWithModifiedTime(value) {
|
|
return !!value.watcher;
|
|
}
|
|
function getModifiedTime2(state, fileName) {
|
|
const path = toPath2(state, fileName);
|
|
const existing = state.filesWatched.get(path);
|
|
if (state.watch && !!existing) {
|
|
if (!isFileWatcherWithModifiedTime(existing))
|
|
return existing;
|
|
if (existing.modifiedTime)
|
|
return existing.modifiedTime;
|
|
}
|
|
const result = 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) {
|
|
const path = toPath2(state, file);
|
|
const existing = state.filesWatched.get(path);
|
|
if (existing && isFileWatcherWithModifiedTime(existing)) {
|
|
existing.callbacks.push(callback);
|
|
} else {
|
|
const watcher = state.watchFile(
|
|
file,
|
|
(fileName, eventKind, modifiedTime) => {
|
|
const existing2 = Debug.checkDefined(state.filesWatched.get(path));
|
|
Debug.assert(isFileWatcherWithModifiedTime(existing2));
|
|
existing2.modifiedTime = modifiedTime;
|
|
existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
|
|
},
|
|
pollingInterval,
|
|
options,
|
|
watchType,
|
|
project
|
|
);
|
|
state.filesWatched.set(path, { callbacks: [callback], watcher, modifiedTime: existing });
|
|
}
|
|
return {
|
|
close: () => {
|
|
const existing2 = Debug.checkDefined(state.filesWatched.get(path));
|
|
Debug.assert(isFileWatcherWithModifiedTime(existing2));
|
|
if (existing2.callbacks.length === 1) {
|
|
state.filesWatched.delete(path);
|
|
closeFileWatcherOf(existing2);
|
|
} else {
|
|
unorderedRemoveItem(existing2.callbacks, callback);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function getOutputTimeStampMap(state, resolvedConfigFilePath) {
|
|
if (!state.watch)
|
|
return void 0;
|
|
let result = state.outputTimeStamps.get(resolvedConfigFilePath);
|
|
if (!result)
|
|
state.outputTimeStamps.set(resolvedConfigFilePath, result = /* @__PURE__ */ new Map());
|
|
return result;
|
|
}
|
|
function setBuildInfo(state, buildInfo, resolvedConfigPath, options, resultFlags) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
const existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
|
|
const modifiedTime = getCurrentTime(state.host);
|
|
if (existing) {
|
|
existing.buildInfo = buildInfo;
|
|
existing.modifiedTime = modifiedTime;
|
|
if (!(resultFlags & 2 /* DeclarationOutputUnchanged */))
|
|
existing.latestChangedDtsTime = modifiedTime;
|
|
} else {
|
|
state.buildInfoCache.set(resolvedConfigPath, {
|
|
path: toPath2(state, buildInfoPath),
|
|
buildInfo,
|
|
modifiedTime,
|
|
latestChangedDtsTime: resultFlags & 2 /* DeclarationOutputUnchanged */ ? void 0 : modifiedTime
|
|
});
|
|
}
|
|
}
|
|
function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
|
|
const path = toPath2(state, buildInfoPath);
|
|
const existing = state.buildInfoCache.get(resolvedConfigPath);
|
|
return (existing == null ? void 0 : existing.path) === path ? existing : void 0;
|
|
}
|
|
function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
|
|
const path = toPath2(state, buildInfoPath);
|
|
const existing = state.buildInfoCache.get(resolvedConfigPath);
|
|
if (existing !== void 0 && existing.path === path) {
|
|
return existing.buildInfo || void 0;
|
|
}
|
|
const value = state.readFileWithCache(buildInfoPath);
|
|
const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
|
|
state.buildInfoCache.set(resolvedConfigPath, { path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
|
|
return buildInfo;
|
|
}
|
|
function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
|
|
const tsconfigTime = getModifiedTime2(state, configFile);
|
|
if (oldestOutputFileTime < tsconfigTime) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerInputFileName: configFile
|
|
};
|
|
}
|
|
}
|
|
function getUpToDateStatusWorker(state, project, resolvedPath) {
|
|
var _a2, _b;
|
|
if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
|
|
return {
|
|
type: 15 /* ContainerOnly */
|
|
};
|
|
}
|
|
let referenceStatuses;
|
|
const force = !!state.options.force;
|
|
if (project.projectReferences) {
|
|
state.projectStatus.set(resolvedPath, { type: 12 /* ComputingUpstream */ });
|
|
for (const ref of project.projectReferences) {
|
|
const resolvedRef = resolveProjectReferencePath(ref);
|
|
const resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
|
|
const resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath);
|
|
const refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath);
|
|
if (refStatus.type === 12 /* ComputingUpstream */ || refStatus.type === 15 /* ContainerOnly */) {
|
|
continue;
|
|
}
|
|
if (refStatus.type === 0 /* Unbuildable */ || refStatus.type === 11 /* UpstreamBlocked */) {
|
|
return {
|
|
type: 11 /* UpstreamBlocked */,
|
|
upstreamProjectName: ref.path,
|
|
upstreamProjectBlocked: refStatus.type === 11 /* UpstreamBlocked */
|
|
};
|
|
}
|
|
if (refStatus.type !== 1 /* UpToDate */) {
|
|
return {
|
|
type: 10 /* UpstreamOutOfDate */,
|
|
upstreamProjectName: ref.path
|
|
};
|
|
}
|
|
if (!force)
|
|
(referenceStatuses || (referenceStatuses = [])).push({ ref, refStatus, resolvedRefPath, resolvedConfig });
|
|
}
|
|
}
|
|
if (force)
|
|
return { type: 16 /* ForceBuild */ };
|
|
const { host } = state;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(project.options);
|
|
let oldestOutputFileName;
|
|
let oldestOutputFileTime = maximumDate;
|
|
let buildInfoTime;
|
|
let buildInfoProgram;
|
|
let buildInfoVersionMap;
|
|
if (buildInfoPath) {
|
|
const buildInfoCacheEntry2 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
|
|
buildInfoTime = (buildInfoCacheEntry2 == null ? void 0 : buildInfoCacheEntry2.modifiedTime) || getModifiedTime(host, buildInfoPath);
|
|
if (buildInfoTime === missingFileModifiedTime) {
|
|
if (!buildInfoCacheEntry2) {
|
|
state.buildInfoCache.set(resolvedPath, {
|
|
path: toPath2(state, buildInfoPath),
|
|
buildInfo: false,
|
|
modifiedTime: buildInfoTime
|
|
});
|
|
}
|
|
return {
|
|
type: 4 /* OutputMissing */,
|
|
missingOutputFileName: buildInfoPath
|
|
};
|
|
}
|
|
const buildInfo = getBuildInfo3(state, buildInfoPath, resolvedPath, buildInfoTime);
|
|
if (!buildInfo) {
|
|
return {
|
|
type: 5 /* ErrorReadingFile */,
|
|
fileName: buildInfoPath
|
|
};
|
|
}
|
|
if ((buildInfo.bundle || buildInfo.program) && buildInfo.version !== version) {
|
|
return {
|
|
type: 13 /* TsVersionOutputOfDate */,
|
|
version: buildInfo.version
|
|
};
|
|
}
|
|
if (buildInfo.program) {
|
|
if (((_a2 = buildInfo.program.changeFileSet) == null ? void 0 : _a2.length) || (!project.options.noEmit ? (_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
|
|
return {
|
|
type: 8 /* OutOfDateBuildInfo */,
|
|
buildInfoFile: buildInfoPath
|
|
};
|
|
}
|
|
if (!project.options.noEmit && getPendingEmitKind(project.options, buildInfo.program.options || {})) {
|
|
return {
|
|
type: 9 /* OutOfDateOptions */,
|
|
buildInfoFile: buildInfoPath
|
|
};
|
|
}
|
|
buildInfoProgram = buildInfo.program;
|
|
}
|
|
oldestOutputFileTime = buildInfoTime;
|
|
oldestOutputFileName = buildInfoPath;
|
|
}
|
|
let newestInputFileName = void 0;
|
|
let newestInputFileTime = minimumDate;
|
|
let pseudoInputUpToDate = false;
|
|
for (const inputFile of project.fileNames) {
|
|
const inputTime = getModifiedTime2(state, inputFile);
|
|
if (inputTime === missingFileModifiedTime) {
|
|
return {
|
|
type: 0 /* Unbuildable */,
|
|
reason: `${inputFile} does not exist`
|
|
};
|
|
}
|
|
if (buildInfoTime && buildInfoTime < inputTime) {
|
|
let version2;
|
|
let currentVersion;
|
|
if (buildInfoProgram) {
|
|
if (!buildInfoVersionMap)
|
|
buildInfoVersionMap = getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);
|
|
version2 = buildInfoVersionMap.get(toPath2(state, inputFile));
|
|
const text = version2 ? state.readFileWithCache(inputFile) : void 0;
|
|
currentVersion = text && getSourceFileVersionAsHashFromText(host, text);
|
|
if (version2 && version2 === currentVersion)
|
|
pseudoInputUpToDate = true;
|
|
}
|
|
if (!version2 || version2 !== currentVersion) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: buildInfoPath,
|
|
newerInputFileName: inputFile
|
|
};
|
|
}
|
|
}
|
|
if (inputTime > newestInputFileTime) {
|
|
newestInputFileName = inputFile;
|
|
newestInputFileTime = inputTime;
|
|
}
|
|
}
|
|
if (!buildInfoPath) {
|
|
const outputs = getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
|
|
const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
|
|
for (const output of outputs) {
|
|
const path = toPath2(state, output);
|
|
let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path);
|
|
if (!outputTime) {
|
|
outputTime = getModifiedTime(state.host, output);
|
|
outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path, outputTime);
|
|
}
|
|
if (outputTime === missingFileModifiedTime) {
|
|
return {
|
|
type: 4 /* OutputMissing */,
|
|
missingOutputFileName: output
|
|
};
|
|
}
|
|
if (outputTime < newestInputFileTime) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: output,
|
|
newerInputFileName: newestInputFileName
|
|
};
|
|
}
|
|
if (outputTime < oldestOutputFileTime) {
|
|
oldestOutputFileTime = outputTime;
|
|
oldestOutputFileName = output;
|
|
}
|
|
}
|
|
}
|
|
const buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath);
|
|
let pseudoUpToDate = false;
|
|
let usesPrepend = false;
|
|
let upstreamChangedProject;
|
|
if (referenceStatuses) {
|
|
for (const { ref, refStatus, resolvedConfig, resolvedRefPath } of referenceStatuses) {
|
|
usesPrepend = usesPrepend || !!ref.prepend;
|
|
if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
|
|
continue;
|
|
}
|
|
if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath)) {
|
|
return {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: buildInfoPath,
|
|
newerProjectName: ref.path
|
|
};
|
|
}
|
|
const newestDeclarationFileContentChangedTime = getLatestChangedDtsTime(state, resolvedConfig.options, resolvedRefPath);
|
|
if (newestDeclarationFileContentChangedTime && newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
|
|
pseudoUpToDate = true;
|
|
upstreamChangedProject = ref.path;
|
|
continue;
|
|
}
|
|
Debug.assert(oldestOutputFileName !== void 0, "Should have an oldest output filename here");
|
|
return {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerProjectName: ref.path
|
|
};
|
|
}
|
|
}
|
|
const configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
|
|
if (configStatus)
|
|
return configStatus;
|
|
const extendedConfigStatus = forEach(project.options.configFile.extendedSourceFiles || emptyArray, (configFile) => checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName));
|
|
if (extendedConfigStatus)
|
|
return extendedConfigStatus;
|
|
const dependentPackageFileStatus = forEach(
|
|
state.lastCachedPackageJsonLookups.get(resolvedPath) || emptyArray,
|
|
([path]) => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName)
|
|
);
|
|
if (dependentPackageFileStatus)
|
|
return dependentPackageFileStatus;
|
|
if (usesPrepend && pseudoUpToDate) {
|
|
return {
|
|
type: 3 /* OutOfDateWithPrepend */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerProjectName: upstreamChangedProject
|
|
};
|
|
}
|
|
return {
|
|
type: pseudoUpToDate ? 2 /* UpToDateWithUpstreamTypes */ : pseudoInputUpToDate ? 14 /* UpToDateWithInputFileText */ : 1 /* UpToDate */,
|
|
newestInputFileTime,
|
|
newestInputFileName,
|
|
oldestOutputFileName
|
|
};
|
|
}
|
|
function hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath) {
|
|
const refBuildInfo = state.buildInfoCache.get(resolvedRefPath);
|
|
return refBuildInfo.path === buildInfoCacheEntry.path;
|
|
}
|
|
function getUpToDateStatus(state, project, resolvedPath) {
|
|
if (project === void 0) {
|
|
return { type: 0 /* Unbuildable */, reason: "File deleted mid-build" };
|
|
}
|
|
const prior = state.projectStatus.get(resolvedPath);
|
|
if (prior !== void 0) {
|
|
return prior;
|
|
}
|
|
mark("SolutionBuilder::beforeUpToDateCheck");
|
|
const actual = getUpToDateStatusWorker(state, project, resolvedPath);
|
|
mark("SolutionBuilder::afterUpToDateCheck");
|
|
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;
|
|
let now;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(proj.options);
|
|
if (buildInfoPath) {
|
|
if (!(skipOutputs == null ? void 0 : skipOutputs.has(toPath2(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;
|
|
}
|
|
const { host } = state;
|
|
const outputs = getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
|
|
const outputTimeStampMap = getOutputTimeStampMap(state, projectPath);
|
|
const modifiedOutputs = outputTimeStampMap ? /* @__PURE__ */ new Set() : void 0;
|
|
if (!skipOutputs || outputs.length !== skipOutputs.size) {
|
|
let reportVerbose = !!state.options.verbose;
|
|
for (const file of outputs) {
|
|
const path = toPath2(state, file);
|
|
if (skipOutputs == null ? void 0 : skipOutputs.has(path))
|
|
continue;
|
|
if (reportVerbose) {
|
|
reportVerbose = false;
|
|
reportStatus(state, verboseMessage, proj.options.configFilePath);
|
|
}
|
|
host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
|
|
if (outputTimeStampMap) {
|
|
outputTimeStampMap.set(path, now);
|
|
modifiedOutputs.add(path);
|
|
}
|
|
}
|
|
}
|
|
outputTimeStampMap == null ? void 0 : outputTimeStampMap.forEach((_value, key) => {
|
|
if (!(skipOutputs == null ? void 0 : skipOutputs.has(key)) && !modifiedOutputs.has(key))
|
|
outputTimeStampMap.delete(key);
|
|
});
|
|
}
|
|
function getLatestChangedDtsTime(state, options, resolvedConfigPath) {
|
|
if (!options.composite)
|
|
return void 0;
|
|
const entry = Debug.checkDefined(state.buildInfoCache.get(resolvedConfigPath));
|
|
if (entry.latestChangedDtsTime !== void 0)
|
|
return entry.latestChangedDtsTime || void 0;
|
|
const latestChangedDtsTime = entry.buildInfo && entry.buildInfo.program && entry.buildInfo.program.latestChangedDtsFile ? state.host.getModifiedTime(getNormalizedAbsolutePath(entry.buildInfo.program.latestChangedDtsFile, getDirectoryPath(entry.path))) : void 0;
|
|
entry.latestChangedDtsTime = latestChangedDtsTime || false;
|
|
return latestChangedDtsTime;
|
|
}
|
|
function updateOutputTimestamps(state, proj, resolvedPath) {
|
|
if (state.options.dry) {
|
|
return reportStatus(state, Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath);
|
|
}
|
|
updateOutputTimestampsWorker(state, proj, resolvedPath, Diagnostics.Updating_output_timestamps_of_project_0);
|
|
state.projectStatus.set(resolvedPath, {
|
|
type: 1 /* UpToDate */,
|
|
oldestOutputFileName: getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
|
|
});
|
|
}
|
|
function queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, buildResult) {
|
|
if (buildResult & 124 /* AnyErrors */)
|
|
return;
|
|
if (!config.options.composite)
|
|
return;
|
|
for (let index = projectIndex + 1; index < buildOrder.length; index++) {
|
|
const nextProject = buildOrder[index];
|
|
const nextProjectPath = toResolvedConfigFilePath(state, nextProject);
|
|
if (state.projectPendingBuild.has(nextProjectPath))
|
|
continue;
|
|
const nextProjectConfig = parseConfigFile(state, nextProject, nextProjectPath);
|
|
if (!nextProjectConfig || !nextProjectConfig.projectReferences)
|
|
continue;
|
|
for (const ref of nextProjectConfig.projectReferences) {
|
|
const resolvedRefPath = resolveProjectName(state, ref.path);
|
|
if (toResolvedConfigFilePath(state, resolvedRefPath) !== projectPath)
|
|
continue;
|
|
const status = state.projectStatus.get(nextProjectPath);
|
|
if (status) {
|
|
switch (status.type) {
|
|
case 1 /* UpToDate */:
|
|
if (buildResult & 2 /* DeclarationOutputUnchanged */) {
|
|
if (ref.prepend) {
|
|
state.projectStatus.set(nextProjectPath, {
|
|
type: 3 /* OutOfDateWithPrepend */,
|
|
outOfDateOutputFileName: status.oldestOutputFileName,
|
|
newerProjectName: project
|
|
});
|
|
} else {
|
|
status.type = 2 /* UpToDateWithUpstreamTypes */;
|
|
}
|
|
break;
|
|
}
|
|
case 14 /* UpToDateWithInputFileText */:
|
|
case 2 /* UpToDateWithUpstreamTypes */:
|
|
case 3 /* OutOfDateWithPrepend */:
|
|
if (!(buildResult & 2 /* DeclarationOutputUnchanged */)) {
|
|
state.projectStatus.set(nextProjectPath, {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: status.type === 3 /* OutOfDateWithPrepend */ ? status.outOfDateOutputFileName : status.oldestOutputFileName,
|
|
newerProjectName: project
|
|
});
|
|
}
|
|
break;
|
|
case 11 /* UpstreamBlocked */:
|
|
if (toResolvedConfigFilePath(state, resolveProjectName(state, status.upstreamProjectName)) === projectPath) {
|
|
clearProjectStatus(state, nextProjectPath);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
addProjToQueue(state, nextProjectPath, 0 /* None */);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function build(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences) {
|
|
mark("SolutionBuilder::beforeBuild");
|
|
const result = buildWorker(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences);
|
|
mark("SolutionBuilder::afterBuild");
|
|
measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
|
|
return result;
|
|
}
|
|
function buildWorker(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences) {
|
|
const buildOrder = getBuildOrderFor(state, project, onlyReferences);
|
|
if (!buildOrder)
|
|
return 3 /* InvalidProject_OutputsSkipped */;
|
|
setupInitialBuild(state, cancellationToken);
|
|
let reportQueue = true;
|
|
let successfulProjects = 0;
|
|
while (true) {
|
|
const invalidatedProject = getNextInvalidatedProject(state, buildOrder, reportQueue);
|
|
if (!invalidatedProject)
|
|
break;
|
|
reportQueue = false;
|
|
invalidatedProject.done(cancellationToken, writeFile2, getCustomTransformers == null ? void 0 : getCustomTransformers(invalidatedProject.project));
|
|
if (!state.diagnostics.has(invalidatedProject.projectPath))
|
|
successfulProjects++;
|
|
}
|
|
disableCache(state);
|
|
reportErrorSummary(state, buildOrder);
|
|
startWatching(state, buildOrder);
|
|
return isCircularBuildOrder(buildOrder) ? 4 /* ProjectReferenceCycle_OutputsSkipped */ : !buildOrder.some((p) => state.diagnostics.has(toResolvedConfigFilePath(state, p))) ? 0 /* Success */ : successfulProjects ? 2 /* DiagnosticsPresent_OutputsGenerated */ : 1 /* DiagnosticsPresent_OutputsSkipped */;
|
|
}
|
|
function clean(state, project, onlyReferences) {
|
|
mark("SolutionBuilder::beforeClean");
|
|
const result = cleanWorker(state, project, onlyReferences);
|
|
mark("SolutionBuilder::afterClean");
|
|
measure("SolutionBuilder::Clean", "SolutionBuilder::beforeClean", "SolutionBuilder::afterClean");
|
|
return result;
|
|
}
|
|
function cleanWorker(state, project, onlyReferences) {
|
|
const buildOrder = getBuildOrderFor(state, project, onlyReferences);
|
|
if (!buildOrder)
|
|
return 3 /* InvalidProject_OutputsSkipped */;
|
|
if (isCircularBuildOrder(buildOrder)) {
|
|
reportErrors(state, buildOrder.circularDiagnostics);
|
|
return 4 /* ProjectReferenceCycle_OutputsSkipped */;
|
|
}
|
|
const { options, host } = state;
|
|
const filesToDelete = options.dry ? [] : void 0;
|
|
for (const proj of buildOrder) {
|
|
const resolvedPath = toResolvedConfigFilePath(state, proj);
|
|
const parsed = parseConfigFile(state, proj, resolvedPath);
|
|
if (parsed === void 0) {
|
|
reportParseConfigFileDiagnostic(state, resolvedPath);
|
|
continue;
|
|
}
|
|
const outputs = getAllProjectOutputs(parsed, !host.useCaseSensitiveFileNames());
|
|
if (!outputs.length)
|
|
continue;
|
|
const inputFileNames = new Set(parsed.fileNames.map((f) => toPath2(state, f)));
|
|
for (const output of outputs) {
|
|
if (inputFileNames.has(toPath2(state, output)))
|
|
continue;
|
|
if (host.fileExists(output)) {
|
|
if (filesToDelete) {
|
|
filesToDelete.push(output);
|
|
} else {
|
|
host.deleteFile(output);
|
|
invalidateProject(state, resolvedPath, 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (filesToDelete) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map((f) => `\r
|
|
* ${f}`).join(""));
|
|
}
|
|
return 0 /* Success */;
|
|
}
|
|
function invalidateProject(state, resolved, reloadLevel) {
|
|
if (state.host.getParsedCommandLine && reloadLevel === 1 /* Partial */) {
|
|
reloadLevel = 2 /* Full */;
|
|
}
|
|
if (reloadLevel === 2 /* Full */) {
|
|
state.configFileCache.delete(resolved);
|
|
state.buildOrder = void 0;
|
|
}
|
|
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, true);
|
|
}
|
|
function scheduleBuildInvalidatedProject(state, time, changeDetected) {
|
|
const { hostWithWatch } = state;
|
|
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) {
|
|
mark("SolutionBuilder::beforeBuild");
|
|
const buildOrder = buildNextInvalidatedProjectWorker(state, changeDetected);
|
|
mark("SolutionBuilder::afterBuild");
|
|
measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
|
|
if (buildOrder)
|
|
reportErrorSummary(state, buildOrder);
|
|
}
|
|
function buildNextInvalidatedProjectWorker(state, changeDetected) {
|
|
state.timerToBuildInvalidatedProject = void 0;
|
|
if (state.reportFileChangeDetected) {
|
|
state.reportFileChangeDetected = false;
|
|
state.projectErrorsReported.clear();
|
|
reportWatchStatus(state, Diagnostics.File_change_detected_Starting_incremental_compilation);
|
|
}
|
|
let projectsBuilt = 0;
|
|
const buildOrder = getBuildOrder(state);
|
|
const invalidatedProject = getNextInvalidatedProject(state, buildOrder, false);
|
|
if (invalidatedProject) {
|
|
invalidatedProject.done();
|
|
projectsBuilt++;
|
|
while (state.projectPendingBuild.size) {
|
|
if (state.timerToBuildInvalidatedProject)
|
|
return;
|
|
const info = getNextInvalidatedProjectCreateInfo(state, buildOrder, false);
|
|
if (!info)
|
|
break;
|
|
if (info.kind !== 2 /* UpdateOutputFileStamps */ && (changeDetected || projectsBuilt === 5)) {
|
|
scheduleBuildInvalidatedProject(state, 100, false);
|
|
return;
|
|
}
|
|
const project = createInvalidatedProjectWithInfo(state, info, buildOrder);
|
|
project.done();
|
|
if (info.kind !== 2 /* 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,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 2 /* Full */),
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.ConfigFile,
|
|
resolved
|
|
));
|
|
}
|
|
function watchExtendedConfigFiles(state, resolvedPath, parsed) {
|
|
updateSharedExtendedConfigFileWatcher(
|
|
resolvedPath,
|
|
parsed == null ? void 0 : parsed.options,
|
|
state.allWatchedExtendedConfigFiles,
|
|
(extendedConfigFileName, extendedConfigFilePath) => watchFile(
|
|
state,
|
|
extendedConfigFileName,
|
|
() => {
|
|
var _a2;
|
|
return (_a2 = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) == null ? void 0 : _a2.projects.forEach((projectConfigFilePath) => invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, 2 /* Full */));
|
|
},
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.ExtendedConfigFile
|
|
),
|
|
(fileName) => toPath2(state, fileName)
|
|
);
|
|
}
|
|
function watchWildCardDirectories(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch)
|
|
return;
|
|
updateWatchingWildcardDirectories(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath),
|
|
new Map(getEntries(parsed.wildcardDirectories)),
|
|
(dir, flags) => state.watchDirectory(
|
|
dir,
|
|
(fileOrDirectory) => {
|
|
var _a2;
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath2(state, dir),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath: toPath2(state, fileOrDirectory),
|
|
configFileName: resolved,
|
|
currentDirectory: state.currentDirectory,
|
|
options: parsed.options,
|
|
program: state.builderPrograms.get(resolvedPath) || ((_a2 = getCachedParsedConfigFile(state, resolvedPath)) == null ? void 0 : _a2.fileNames),
|
|
useCaseSensitiveFileNames: state.parseConfigFileHost.useCaseSensitiveFileNames,
|
|
writeLog: (s) => state.writeLog(s),
|
|
toPath: (fileName) => toPath2(state, fileName)
|
|
}))
|
|
return;
|
|
invalidateProjectAndScheduleBuilds(state, resolvedPath, 1 /* Partial */);
|
|
},
|
|
flags,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.WildcardDirectory,
|
|
resolved
|
|
)
|
|
);
|
|
}
|
|
function watchInputFiles(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch)
|
|
return;
|
|
mutateMap(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath),
|
|
arrayToMap(parsed.fileNames, (fileName) => toPath2(state, fileName)),
|
|
{
|
|
createNewValue: (_path, input) => watchFile(
|
|
state,
|
|
input,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* None */),
|
|
250 /* Low */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.SourceFile,
|
|
resolved
|
|
),
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function watchPackageJsonFiles(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch || !state.lastCachedPackageJsonLookups)
|
|
return;
|
|
mutateMap(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath),
|
|
new Map(state.lastCachedPackageJsonLookups.get(resolvedPath)),
|
|
{
|
|
createNewValue: (path, _input) => watchFile(
|
|
state,
|
|
path,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* None */),
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.PackageJson,
|
|
resolved
|
|
),
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function startWatching(state, buildOrder) {
|
|
if (!state.watchAllProjectsPending)
|
|
return;
|
|
mark("SolutionBuilder::beforeWatcherCreation");
|
|
state.watchAllProjectsPending = false;
|
|
for (const resolved of getBuildOrderFromAnyBuildOrder(buildOrder)) {
|
|
const resolvedPath = toResolvedConfigFilePath(state, resolved);
|
|
const cfg = parseConfigFile(state, resolved, resolvedPath);
|
|
watchConfigFile(state, resolved, resolvedPath, cfg);
|
|
watchExtendedConfigFiles(state, resolvedPath, cfg);
|
|
if (cfg) {
|
|
watchWildCardDirectories(state, resolved, resolvedPath, cfg);
|
|
watchInputFiles(state, resolved, resolvedPath, cfg);
|
|
watchPackageJsonFiles(state, resolved, resolvedPath, cfg);
|
|
}
|
|
}
|
|
mark("SolutionBuilder::afterWatcherCreation");
|
|
measure("SolutionBuilder::Watcher creation", "SolutionBuilder::beforeWatcherCreation", "SolutionBuilder::afterWatcherCreation");
|
|
}
|
|
function stopWatching(state) {
|
|
clearMap(state.allWatchedConfigFiles, closeFileWatcher);
|
|
clearMap(state.allWatchedExtendedConfigFiles, closeFileWatcherOf);
|
|
clearMap(state.allWatchedWildcardDirectories, (watchedWildcardDirectories) => clearMap(watchedWildcardDirectories, closeFileWatcherOf));
|
|
clearMap(state.allWatchedInputFiles, (watchedWildcardDirectories) => clearMap(watchedWildcardDirectories, closeFileWatcher));
|
|
clearMap(state.allWatchedPackageJsonFiles, (watchedPacageJsonFiles) => clearMap(watchedPacageJsonFiles, closeFileWatcher));
|
|
}
|
|
function createSolutionBuilderWorker(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) {
|
|
const state = createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions);
|
|
return {
|
|
build: (project, cancellationToken, writeFile2, getCustomTransformers) => build(state, project, cancellationToken, writeFile2, getCustomTransformers),
|
|
clean: (project) => clean(state, project),
|
|
buildReferences: (project, cancellationToken, writeFile2, getCustomTransformers) => build(state, project, cancellationToken, writeFile2, getCustomTransformers, true),
|
|
cleanReferences: (project) => clean(state, project, true),
|
|
getNextInvalidatedProject: (cancellationToken) => {
|
|
setupInitialBuild(state, cancellationToken);
|
|
return getNextInvalidatedProject(state, getBuildOrder(state), false);
|
|
},
|
|
getBuildOrder: () => getBuildOrder(state),
|
|
getUpToDateStatusOfProject: (project) => {
|
|
const configFileName = resolveProjectName(state, project);
|
|
const configFilePath = toResolvedConfigFilePath(state, configFileName);
|
|
return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
|
|
},
|
|
invalidateProject: (configFilePath, reloadLevel) => invalidateProject(state, configFilePath, reloadLevel || 0 /* None */),
|
|
close: () => stopWatching(state)
|
|
};
|
|
}
|
|
function relName(state, path) {
|
|
return convertToRelativePath(path, state.currentDirectory, (f) => state.getCanonicalFileName(f));
|
|
}
|
|
function reportStatus(state, message, ...args) {
|
|
state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
|
|
}
|
|
function reportWatchStatus(state, message, ...args) {
|
|
var _a2, _b;
|
|
(_b = (_a2 = state.hostWithWatch).onWatchStatusChange) == null ? void 0 : _b.call(_a2, createCompilerDiagnostic(message, ...args), state.host.getNewLine(), state.baseCompilerOptions);
|
|
}
|
|
function reportErrors({ host }, errors) {
|
|
errors.forEach((err) => 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;
|
|
const canReportSummary = state.watch || !!state.host.reportErrorSummary;
|
|
const { diagnostics } = state;
|
|
let totalErrors = 0;
|
|
let filesInError = [];
|
|
if (isCircularBuildOrder(buildOrder)) {
|
|
reportBuildQueue(state, buildOrder.buildOrder);
|
|
reportErrors(state, buildOrder.circularDiagnostics);
|
|
if (canReportSummary)
|
|
totalErrors += getErrorCountForSummary(buildOrder.circularDiagnostics);
|
|
if (canReportSummary)
|
|
filesInError = [...filesInError, ...getFilesInErrorForSummary(buildOrder.circularDiagnostics)];
|
|
} else {
|
|
buildOrder.forEach((project) => {
|
|
const projectPath = toResolvedConfigFilePath(state, project);
|
|
if (!state.projectErrorsReported.has(projectPath)) {
|
|
reportErrors(state, diagnostics.get(projectPath) || emptyArray);
|
|
}
|
|
});
|
|
if (canReportSummary)
|
|
diagnostics.forEach((singleProjectErrors) => totalErrors += getErrorCountForSummary(singleProjectErrors));
|
|
if (canReportSummary)
|
|
diagnostics.forEach((singleProjectErrors) => [...filesInError, ...getFilesInErrorForSummary(singleProjectErrors)]);
|
|
}
|
|
if (state.watch) {
|
|
reportWatchStatus(state, getWatchErrorSummaryDiagnosticMessage(totalErrors), totalErrors);
|
|
} else if (state.host.reportErrorSummary) {
|
|
state.host.reportErrorSummary(totalErrors, filesInError);
|
|
}
|
|
}
|
|
function reportBuildQueue(state, buildQueue) {
|
|
if (state.options.verbose) {
|
|
reportStatus(state, Diagnostics.Projects_in_this_build_Colon_0, buildQueue.map((s) => "\r\n * " + relName(state, s)).join(""));
|
|
}
|
|
}
|
|
function reportUpToDateStatus(state, configFileName, status) {
|
|
switch (status.type) {
|
|
case 6 /* OutOfDateWithSelf */:
|
|
return reportStatus(
|
|
state,
|
|
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 7 /* OutOfDateWithUpstream */:
|
|
return reportStatus(
|
|
state,
|
|
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 4 /* OutputMissing */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist,
|
|
relName(state, configFileName),
|
|
relName(state, status.missingOutputFileName)
|
|
);
|
|
case 5 /* ErrorReadingFile */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_there_was_error_reading_file_1,
|
|
relName(state, configFileName),
|
|
relName(state, status.fileName)
|
|
);
|
|
case 8 /* OutOfDateBuildInfo */:
|
|
return reportStatus(
|
|
state,
|
|
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 9 /* OutOfDateOptions */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions,
|
|
relName(state, configFileName),
|
|
relName(state, status.buildInfoFile)
|
|
);
|
|
case 1 /* UpToDate */:
|
|
if (status.newestInputFileTime !== void 0) {
|
|
return reportStatus(
|
|
state,
|
|
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 || "")
|
|
);
|
|
}
|
|
break;
|
|
case 3 /* OutOfDateWithPrepend */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed,
|
|
relName(state, configFileName),
|
|
relName(state, status.newerProjectName)
|
|
);
|
|
case 2 /* UpToDateWithUpstreamTypes */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies,
|
|
relName(state, configFileName)
|
|
);
|
|
case 14 /* UpToDateWithInputFileText */:
|
|
return reportStatus(
|
|
state,
|
|
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 10 /* UpstreamOutOfDate */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date,
|
|
relName(state, configFileName),
|
|
relName(state, status.upstreamProjectName)
|
|
);
|
|
case 11 /* UpstreamBlocked */:
|
|
return reportStatus(
|
|
state,
|
|
status.upstreamProjectBlocked ? Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_was_not_built : Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_has_errors,
|
|
relName(state, configFileName),
|
|
relName(state, status.upstreamProjectName)
|
|
);
|
|
case 0 /* Unbuildable */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Failed_to_parse_file_0_Colon_1,
|
|
relName(state, configFileName),
|
|
status.reason
|
|
);
|
|
case 13 /* TsVersionOutputOfDate */:
|
|
return reportStatus(
|
|
state,
|
|
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,
|
|
version
|
|
);
|
|
case 16 /* ForceBuild */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_being_forcibly_rebuilt,
|
|
relName(state, configFileName)
|
|
);
|
|
case 15 /* ContainerOnly */:
|
|
case 12 /* ComputingUpstream */:
|
|
break;
|
|
default:
|
|
assertType(status);
|
|
}
|
|
}
|
|
function verboseReportProjectStatus(state, configFileName, status) {
|
|
if (state.options.verbose) {
|
|
reportUpToDateStatus(state, configFileName, status);
|
|
}
|
|
}
|
|
|
|
// src/executeCommandLine/executeCommandLine.ts
|
|
function countLines(program) {
|
|
const counts2 = getCountsMap();
|
|
forEach(program.getSourceFiles(), (file) => {
|
|
const key = getCountKey(program, file);
|
|
const lineCount = getLineStarts(file).length;
|
|
counts2.set(key, counts2.get(key) + lineCount);
|
|
});
|
|
return counts2;
|
|
}
|
|
function getCountsMap() {
|
|
const counts2 = /* @__PURE__ */ new Map();
|
|
counts2.set("Library", 0);
|
|
counts2.set("Definitions", 0);
|
|
counts2.set("TypeScript", 0);
|
|
counts2.set("JavaScript", 0);
|
|
counts2.set("JSON", 0);
|
|
counts2.set("Other", 0);
|
|
return counts2;
|
|
}
|
|
function getCountKey(program, file) {
|
|
if (program.isSourceFileDefaultLibrary(file)) {
|
|
return "Library";
|
|
} else if (file.isDeclarationFile) {
|
|
return "Definitions";
|
|
}
|
|
const path = file.path;
|
|
if (fileExtensionIsOneOf(path, supportedTSExtensionsFlat)) {
|
|
return "TypeScript";
|
|
} else if (fileExtensionIsOneOf(path, supportedJSExtensionsFlat)) {
|
|
return "JavaScript";
|
|
} else if (fileExtensionIs(path, ".json" /* Json */)) {
|
|
return "JSON";
|
|
} else {
|
|
return "Other";
|
|
}
|
|
}
|
|
function updateReportDiagnostic(sys2, existing, options) {
|
|
return shouldBePretty(sys2, options) ? createDiagnosticReporter(sys2, true) : existing;
|
|
}
|
|
function defaultIsPretty(sys2) {
|
|
return !!sys2.writeOutputIsTTY && sys2.writeOutputIsTTY() && !sys2.getEnvironmentVariable("NO_COLOR");
|
|
}
|
|
function shouldBePretty(sys2, options) {
|
|
if (!options || typeof options.pretty === "undefined") {
|
|
return defaultIsPretty(sys2);
|
|
}
|
|
return options.pretty;
|
|
}
|
|
function getOptionsForHelp(commandLine) {
|
|
return !!commandLine.options.all ? sort(optionDeclarations, (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.slice(), (v) => !!v.showInSimplifiedHelpView);
|
|
}
|
|
function printVersion(sys2) {
|
|
sys2.write(getDiagnosticText(Diagnostics.Version_0, version) + sys2.newLine);
|
|
}
|
|
function createColors(sys2) {
|
|
const showColors = defaultIsPretty(sys2);
|
|
if (!showColors) {
|
|
return {
|
|
bold: (str) => str,
|
|
blue: (str) => str,
|
|
blueBackground: (str) => str,
|
|
brightWhite: (str) => str
|
|
};
|
|
}
|
|
function bold(str) {
|
|
return `\x1B[1m${str}\x1B[22m`;
|
|
}
|
|
const isWindows = sys2.getEnvironmentVariable("OS") && stringContains(sys2.getEnvironmentVariable("OS").toLowerCase(), "windows");
|
|
const isWindowsTerminal = sys2.getEnvironmentVariable("WT_SESSION");
|
|
const isVSCode = sys2.getEnvironmentVariable("TERM_PROGRAM") && sys2.getEnvironmentVariable("TERM_PROGRAM") === "vscode";
|
|
function blue(str) {
|
|
if (isWindows && !isWindowsTerminal && !isVSCode) {
|
|
return brightWhite(str);
|
|
}
|
|
return `\x1B[94m${str}\x1B[39m`;
|
|
}
|
|
const supportsRicherColors = sys2.getEnvironmentVariable("COLORTERM") === "truecolor" || sys2.getEnvironmentVariable("TERM") === "xterm-256color";
|
|
function blueBackground(str) {
|
|
if (supportsRicherColors) {
|
|
return `\x1B[48;5;68m${str}\x1B[39;49m`;
|
|
} else {
|
|
return `\x1B[44m${str}\x1B[39;49m`;
|
|
}
|
|
}
|
|
function brightWhite(str) {
|
|
return `\x1B[97m${str}\x1B[39m`;
|
|
}
|
|
return {
|
|
bold,
|
|
blue,
|
|
brightWhite,
|
|
blueBackground
|
|
};
|
|
}
|
|
function getDisplayNameTextOfOption(option) {
|
|
return `--${option.name}${option.shortName ? `, -${option.shortName}` : ""}`;
|
|
}
|
|
function generateOptionOutput(sys2, option, rightAlignOfLeft, leftAlignOfRight) {
|
|
var _a2, _b;
|
|
const text = [];
|
|
const colors = createColors(sys2);
|
|
const name = getDisplayNameTextOfOption(option);
|
|
const valueCandidates = getValueCandidate(option);
|
|
const defaultValueDescription = typeof option.defaultValueDescription === "object" ? getDiagnosticText(option.defaultValueDescription) : formatDefaultValue(
|
|
option.defaultValueDescription,
|
|
option.type === "list" ? option.element.type : option.type
|
|
);
|
|
const terminalWidth = (_b = (_a2 = sys2.getWidthOfTerminal) == null ? void 0 : _a2.call(sys2)) != null ? _b : 0;
|
|
if (terminalWidth >= 80) {
|
|
let description = "";
|
|
if (option.description) {
|
|
description = getDiagnosticText(option.description);
|
|
}
|
|
text.push(...getPrettyOutput(name, description, rightAlignOfLeft, leftAlignOfRight, terminalWidth, true), sys2.newLine);
|
|
if (showAdditionalInfoOutput(valueCandidates, option)) {
|
|
if (valueCandidates) {
|
|
text.push(...getPrettyOutput(valueCandidates.valueType, valueCandidates.possibleValues, rightAlignOfLeft, leftAlignOfRight, terminalWidth, false), sys2.newLine);
|
|
}
|
|
if (defaultValueDescription) {
|
|
text.push(...getPrettyOutput(getDiagnosticText(Diagnostics.default_Colon), defaultValueDescription, rightAlignOfLeft, leftAlignOfRight, terminalWidth, false), sys2.newLine);
|
|
}
|
|
}
|
|
text.push(sys2.newLine);
|
|
} else {
|
|
text.push(colors.blue(name), sys2.newLine);
|
|
if (option.description) {
|
|
const description = getDiagnosticText(option.description);
|
|
text.push(description);
|
|
}
|
|
text.push(sys2.newLine);
|
|
if (showAdditionalInfoOutput(valueCandidates, option)) {
|
|
if (valueCandidates) {
|
|
text.push(`${valueCandidates.valueType} ${valueCandidates.possibleValues}`);
|
|
}
|
|
if (defaultValueDescription) {
|
|
if (valueCandidates)
|
|
text.push(sys2.newLine);
|
|
const diagType = getDiagnosticText(Diagnostics.default_Colon);
|
|
text.push(`${diagType} ${defaultValueDescription}`);
|
|
}
|
|
text.push(sys2.newLine);
|
|
}
|
|
text.push(sys2.newLine);
|
|
}
|
|
return text;
|
|
function formatDefaultValue(defaultValue, type) {
|
|
return defaultValue !== void 0 && typeof type === "object" ? arrayFrom(type.entries()).filter(([, value]) => value === defaultValue).map(([name2]) => name2).join("/") : String(defaultValue);
|
|
}
|
|
function showAdditionalInfoOutput(valueCandidates2, option2) {
|
|
const ignoreValues = ["string"];
|
|
const ignoredDescriptions = [void 0, "false", "n/a"];
|
|
const defaultValueDescription2 = option2.defaultValueDescription;
|
|
if (option2.category === Diagnostics.Command_line_Options)
|
|
return false;
|
|
if (contains(ignoreValues, valueCandidates2 == null ? void 0 : valueCandidates2.possibleValues) && contains(ignoredDescriptions, defaultValueDescription2)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getPrettyOutput(left, right, rightAlignOfLeft2, leftAlignOfRight2, terminalWidth2, colorLeft) {
|
|
const res = [];
|
|
let isFirstLine = true;
|
|
let remainRight = right;
|
|
const rightCharacterNumber = terminalWidth2 - leftAlignOfRight2;
|
|
while (remainRight.length > 0) {
|
|
let curLeft = "";
|
|
if (isFirstLine) {
|
|
curLeft = padLeft(left, rightAlignOfLeft2);
|
|
curLeft = padRight(curLeft, leftAlignOfRight2);
|
|
curLeft = colorLeft ? colors.blue(curLeft) : curLeft;
|
|
} else {
|
|
curLeft = padLeft("", leftAlignOfRight2);
|
|
}
|
|
const curRight = remainRight.substr(0, rightCharacterNumber);
|
|
remainRight = remainRight.slice(rightCharacterNumber);
|
|
res.push(`${curLeft}${curRight}`);
|
|
isFirstLine = false;
|
|
}
|
|
return res;
|
|
}
|
|
function getValueCandidate(option2) {
|
|
if (option2.type === "object") {
|
|
return void 0;
|
|
}
|
|
return {
|
|
valueType: getValueType(option2),
|
|
possibleValues: getPossibleValues(option2)
|
|
};
|
|
function getValueType(option3) {
|
|
switch (option3.type) {
|
|
case "string":
|
|
case "number":
|
|
case "boolean":
|
|
return getDiagnosticText(Diagnostics.type_Colon);
|
|
case "list":
|
|
return getDiagnosticText(Diagnostics.one_or_more_Colon);
|
|
default:
|
|
return getDiagnosticText(Diagnostics.one_of_Colon);
|
|
}
|
|
}
|
|
function getPossibleValues(option3) {
|
|
let possibleValues;
|
|
switch (option3.type) {
|
|
case "string":
|
|
case "number":
|
|
case "boolean":
|
|
possibleValues = option3.type;
|
|
break;
|
|
case "list":
|
|
possibleValues = getPossibleValues(option3.element);
|
|
break;
|
|
case "object":
|
|
possibleValues = "";
|
|
break;
|
|
default:
|
|
const inverted = {};
|
|
option3.type.forEach((value, name2) => {
|
|
(inverted[value] || (inverted[value] = [])).push(name2);
|
|
});
|
|
return getEntries(inverted).map(([, synonyms]) => synonyms.join("/")).join(", ");
|
|
}
|
|
return possibleValues;
|
|
}
|
|
}
|
|
}
|
|
function generateGroupOptionOutput(sys2, optionsList) {
|
|
let maxLength = 0;
|
|
for (const option of optionsList) {
|
|
const curLength = getDisplayNameTextOfOption(option).length;
|
|
maxLength = maxLength > curLength ? maxLength : curLength;
|
|
}
|
|
const rightAlignOfLeftPart = maxLength + 2;
|
|
const leftAlignOfRightPart = rightAlignOfLeftPart + 2;
|
|
let lines = [];
|
|
for (const option of optionsList) {
|
|
const tmp = generateOptionOutput(sys2, option, rightAlignOfLeftPart, leftAlignOfRightPart);
|
|
lines = [...lines, ...tmp];
|
|
}
|
|
if (lines[lines.length - 2] !== sys2.newLine) {
|
|
lines.push(sys2.newLine);
|
|
}
|
|
return lines;
|
|
}
|
|
function generateSectionOptionsOutput(sys2, sectionName, options, subCategory, beforeOptionsDescription, afterOptionsDescription) {
|
|
var _a2;
|
|
let res = [];
|
|
res.push(createColors(sys2).bold(sectionName) + sys2.newLine + sys2.newLine);
|
|
if (beforeOptionsDescription) {
|
|
res.push(beforeOptionsDescription + sys2.newLine + sys2.newLine);
|
|
}
|
|
if (!subCategory) {
|
|
res = [...res, ...generateGroupOptionOutput(sys2, options)];
|
|
if (afterOptionsDescription) {
|
|
res.push(afterOptionsDescription + sys2.newLine + sys2.newLine);
|
|
}
|
|
return res;
|
|
}
|
|
const categoryMap = /* @__PURE__ */ new Map();
|
|
for (const option of options) {
|
|
if (!option.category) {
|
|
continue;
|
|
}
|
|
const curCategory = getDiagnosticText(option.category);
|
|
const optionsOfCurCategory = (_a2 = categoryMap.get(curCategory)) != null ? _a2 : [];
|
|
optionsOfCurCategory.push(option);
|
|
categoryMap.set(curCategory, optionsOfCurCategory);
|
|
}
|
|
categoryMap.forEach((value, key) => {
|
|
res.push(`### ${key}${sys2.newLine}${sys2.newLine}`);
|
|
res = [...res, ...generateGroupOptionOutput(sys2, value)];
|
|
});
|
|
if (afterOptionsDescription) {
|
|
res.push(afterOptionsDescription + sys2.newLine + sys2.newLine);
|
|
}
|
|
return res;
|
|
}
|
|
function printEasyHelp(sys2, simpleOptions) {
|
|
const colors = createColors(sys2);
|
|
let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
|
|
output.push(colors.bold(getDiagnosticText(Diagnostics.COMMON_COMMANDS)) + sys2.newLine + sys2.newLine);
|
|
example("tsc", Diagnostics.Compiles_the_current_project_tsconfig_json_in_the_working_directory);
|
|
example("tsc app.ts util.ts", Diagnostics.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options);
|
|
example("tsc -b", Diagnostics.Build_a_composite_project_in_the_working_directory);
|
|
example("tsc --init", Diagnostics.Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory);
|
|
example("tsc -p ./path/to/tsconfig.json", Diagnostics.Compiles_the_TypeScript_project_located_at_the_specified_path);
|
|
example("tsc --help --all", Diagnostics.An_expanded_version_of_this_information_showing_all_possible_compiler_options);
|
|
example(["tsc --noEmit", "tsc --target esnext"], Diagnostics.Compiles_the_current_project_with_additional_settings);
|
|
const cliCommands = simpleOptions.filter((opt) => opt.isCommandLineOnly || opt.category === Diagnostics.Command_line_Options);
|
|
const configOpts = simpleOptions.filter((opt) => !contains(cliCommands, opt));
|
|
output = [
|
|
...output,
|
|
...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.COMMAND_LINE_FLAGS), cliCommands, false, void 0, void 0),
|
|
...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.COMMON_COMPILER_OPTIONS), configOpts, false, void 0, formatMessage(void 0, Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc"))
|
|
];
|
|
for (const line of output) {
|
|
sys2.write(line);
|
|
}
|
|
function example(ex, desc) {
|
|
const examples = typeof ex === "string" ? [ex] : ex;
|
|
for (const example2 of examples) {
|
|
output.push(" " + colors.blue(example2) + sys2.newLine);
|
|
}
|
|
output.push(" " + getDiagnosticText(desc) + sys2.newLine + sys2.newLine);
|
|
}
|
|
}
|
|
function printAllHelp(sys2, compilerOptions, buildOptions, watchOptions) {
|
|
let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
|
|
output = [...output, ...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.ALL_COMPILER_OPTIONS), compilerOptions, true, void 0, formatMessage(void 0, Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc"))];
|
|
output = [...output, ...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.WATCH_OPTIONS), watchOptions, false, getDiagnosticText(Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon))];
|
|
output = [...output, ...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.BUILD_OPTIONS), buildOptions, false, formatMessage(void 0, Diagnostics.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, "https://aka.ms/tsc-composite-builds"))];
|
|
for (const line of output) {
|
|
sys2.write(line);
|
|
}
|
|
}
|
|
function printBuildHelp(sys2, buildOptions) {
|
|
let output = [...getHeader(sys2, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];
|
|
output = [...output, ...generateSectionOptionsOutput(sys2, getDiagnosticText(Diagnostics.BUILD_OPTIONS), buildOptions, false, formatMessage(void 0, Diagnostics.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, "https://aka.ms/tsc-composite-builds"))];
|
|
for (const line of output) {
|
|
sys2.write(line);
|
|
}
|
|
}
|
|
function getHeader(sys2, message) {
|
|
var _a2, _b;
|
|
const colors = createColors(sys2);
|
|
const header = [];
|
|
const terminalWidth = (_b = (_a2 = sys2.getWidthOfTerminal) == null ? void 0 : _a2.call(sys2)) != null ? _b : 0;
|
|
const tsIconLength = 5;
|
|
const tsIconFirstLine = colors.blueBackground(padLeft("", tsIconLength));
|
|
const tsIconSecondLine = colors.blueBackground(colors.brightWhite(padLeft("TS ", tsIconLength)));
|
|
if (terminalWidth >= message.length + tsIconLength) {
|
|
const rightAlign = terminalWidth > 120 ? 120 : terminalWidth;
|
|
const leftAlign = rightAlign - tsIconLength;
|
|
header.push(padRight(message, leftAlign) + tsIconFirstLine + sys2.newLine);
|
|
header.push(padLeft("", leftAlign) + tsIconSecondLine + sys2.newLine);
|
|
} else {
|
|
header.push(message + sys2.newLine);
|
|
header.push(sys2.newLine);
|
|
}
|
|
return header;
|
|
}
|
|
function printHelp(sys2, commandLine) {
|
|
if (!commandLine.options.all) {
|
|
printEasyHelp(sys2, getOptionsForHelp(commandLine));
|
|
} else {
|
|
printAllHelp(sys2, getOptionsForHelp(commandLine), optionsForBuild, optionsForWatch);
|
|
}
|
|
}
|
|
function executeCommandLineWorker(sys2, cb, commandLine) {
|
|
let reportDiagnostic = createDiagnosticReporter(sys2);
|
|
if (commandLine.options.build) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_build_must_be_the_first_command_line_argument));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
let configFileName;
|
|
if (commandLine.options.locale) {
|
|
validateLocaleAndSetLanguage(commandLine.options.locale, sys2, commandLine.errors);
|
|
}
|
|
if (commandLine.errors.length > 0) {
|
|
commandLine.errors.forEach(reportDiagnostic);
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
if (commandLine.options.init) {
|
|
writeConfigFile(sys2, reportDiagnostic, commandLine.options, commandLine.fileNames);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
if (commandLine.options.version) {
|
|
printVersion(sys2);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
if (commandLine.options.help || commandLine.options.all) {
|
|
printHelp(sys2, commandLine);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
if (commandLine.options.watch && commandLine.options.listFilesOnly) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly"));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
if (commandLine.options.project) {
|
|
if (commandLine.fileNames.length !== 0) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
const fileOrDirectory = normalizePath(commandLine.options.project);
|
|
if (!fileOrDirectory || sys2.directoryExists(fileOrDirectory)) {
|
|
configFileName = combinePaths(fileOrDirectory, "tsconfig.json");
|
|
if (!sys2.fileExists(configFileName)) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
} else {
|
|
configFileName = fileOrDirectory;
|
|
if (!sys2.fileExists(configFileName)) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
}
|
|
} else if (commandLine.fileNames.length === 0) {
|
|
const searchPath = normalizePath(sys2.getCurrentDirectory());
|
|
configFileName = findConfigFile(searchPath, (fileName) => sys2.fileExists(fileName));
|
|
}
|
|
if (commandLine.fileNames.length === 0 && !configFileName) {
|
|
if (commandLine.options.showConfig) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, normalizePath(sys2.getCurrentDirectory())));
|
|
} else {
|
|
printVersion(sys2);
|
|
printHelp(sys2, commandLine);
|
|
}
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
const currentDirectory = sys2.getCurrentDirectory();
|
|
const commandLineOptions = convertToOptionsWithAbsolutePaths(
|
|
commandLine.options,
|
|
(fileName) => getNormalizedAbsolutePath(fileName, currentDirectory)
|
|
);
|
|
if (configFileName) {
|
|
const extendedConfigCache = /* @__PURE__ */ new Map();
|
|
const configParseResult = parseConfigFileWithSystem(configFileName, commandLineOptions, extendedConfigCache, commandLine.watchOptions, sys2, reportDiagnostic);
|
|
if (commandLineOptions.showConfig) {
|
|
if (configParseResult.errors.length !== 0) {
|
|
reportDiagnostic = updateReportDiagnostic(
|
|
sys2,
|
|
reportDiagnostic,
|
|
configParseResult.options
|
|
);
|
|
configParseResult.errors.forEach(reportDiagnostic);
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
sys2.write(JSON.stringify(convertToTSConfig(configParseResult, configFileName, sys2), null, 4) + sys2.newLine);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
reportDiagnostic = updateReportDiagnostic(
|
|
sys2,
|
|
reportDiagnostic,
|
|
configParseResult.options
|
|
);
|
|
if (isWatchSet(configParseResult.options)) {
|
|
if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
|
|
return;
|
|
return createWatchOfConfigFile(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
configParseResult,
|
|
commandLineOptions,
|
|
commandLine.watchOptions,
|
|
extendedConfigCache
|
|
);
|
|
} else if (isIncrementalCompilation(configParseResult.options)) {
|
|
performIncrementalCompilation2(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
configParseResult
|
|
);
|
|
} else {
|
|
performCompilation(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
configParseResult
|
|
);
|
|
}
|
|
} else {
|
|
if (commandLineOptions.showConfig) {
|
|
sys2.write(JSON.stringify(convertToTSConfig(commandLine, combinePaths(currentDirectory, "tsconfig.json"), sys2), null, 4) + sys2.newLine);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
reportDiagnostic = updateReportDiagnostic(
|
|
sys2,
|
|
reportDiagnostic,
|
|
commandLineOptions
|
|
);
|
|
if (isWatchSet(commandLineOptions)) {
|
|
if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
|
|
return;
|
|
return createWatchOfFilesAndCompilerOptions(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
commandLine.fileNames,
|
|
commandLineOptions,
|
|
commandLine.watchOptions
|
|
);
|
|
} else if (isIncrementalCompilation(commandLineOptions)) {
|
|
performIncrementalCompilation2(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
{ ...commandLine, options: commandLineOptions }
|
|
);
|
|
} else {
|
|
performCompilation(
|
|
sys2,
|
|
cb,
|
|
reportDiagnostic,
|
|
{ ...commandLine, options: commandLineOptions }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function isBuild(commandLineArgs) {
|
|
if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === 45 /* minus */) {
|
|
const firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === 45 /* minus */ ? 2 : 1).toLowerCase();
|
|
return firstOption === "build" || firstOption === "b";
|
|
}
|
|
return false;
|
|
}
|
|
function executeCommandLine(system, cb, commandLineArgs) {
|
|
if (isBuild(commandLineArgs)) {
|
|
const { buildOptions, watchOptions, projects, errors } = parseBuildCommand(commandLineArgs.slice(1));
|
|
if (buildOptions.generateCpuProfile && system.enableCPUProfiler) {
|
|
system.enableCPUProfiler(buildOptions.generateCpuProfile, () => performBuild(
|
|
system,
|
|
cb,
|
|
buildOptions,
|
|
watchOptions,
|
|
projects,
|
|
errors
|
|
));
|
|
} else {
|
|
return performBuild(
|
|
system,
|
|
cb,
|
|
buildOptions,
|
|
watchOptions,
|
|
projects,
|
|
errors
|
|
);
|
|
}
|
|
}
|
|
const commandLine = parseCommandLine(commandLineArgs, (path) => system.readFile(path));
|
|
if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
|
|
system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
|
|
system,
|
|
cb,
|
|
commandLine
|
|
));
|
|
} else {
|
|
return executeCommandLineWorker(system, cb, commandLine);
|
|
}
|
|
}
|
|
function reportWatchModeWithoutSysSupport(sys2, reportDiagnostic) {
|
|
if (!sys2.watchFile || !sys2.watchDirectory) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"));
|
|
sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function performBuild(sys2, cb, buildOptions, watchOptions, projects, errors) {
|
|
const reportDiagnostic = updateReportDiagnostic(
|
|
sys2,
|
|
createDiagnosticReporter(sys2),
|
|
buildOptions
|
|
);
|
|
if (buildOptions.locale) {
|
|
validateLocaleAndSetLanguage(buildOptions.locale, sys2, errors);
|
|
}
|
|
if (errors.length > 0) {
|
|
errors.forEach(reportDiagnostic);
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
if (buildOptions.help) {
|
|
printVersion(sys2);
|
|
printBuildHelp(sys2, buildOpts);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
if (projects.length === 0) {
|
|
printVersion(sys2);
|
|
printBuildHelp(sys2, buildOpts);
|
|
return sys2.exit(0 /* Success */);
|
|
}
|
|
if (!sys2.getModifiedTime || !sys2.setModifiedTime || buildOptions.clean && !sys2.deleteFile) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--build"));
|
|
return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
if (buildOptions.watch) {
|
|
if (reportWatchModeWithoutSysSupport(sys2, reportDiagnostic))
|
|
return;
|
|
const buildHost2 = createSolutionBuilderWithWatchHost(
|
|
sys2,
|
|
void 0,
|
|
reportDiagnostic,
|
|
createBuilderStatusReporter(sys2, shouldBePretty(sys2, buildOptions)),
|
|
createWatchStatusReporter2(sys2, buildOptions)
|
|
);
|
|
const solutionPerformance2 = enableSolutionPerformance(sys2, buildOptions);
|
|
updateSolutionBuilderHost(sys2, cb, buildHost2, solutionPerformance2);
|
|
const onWatchStatusChange = buildHost2.onWatchStatusChange;
|
|
let reportBuildStatistics = false;
|
|
buildHost2.onWatchStatusChange = (d, newLine, options, errorCount) => {
|
|
onWatchStatusChange == null ? void 0 : onWatchStatusChange(d, newLine, options, errorCount);
|
|
if (reportBuildStatistics && (d.code === Diagnostics.Found_0_errors_Watching_for_file_changes.code || d.code === Diagnostics.Found_1_error_Watching_for_file_changes.code)) {
|
|
reportSolutionBuilderTimes(builder2, solutionPerformance2);
|
|
}
|
|
};
|
|
const builder2 = createSolutionBuilderWithWatch(buildHost2, projects, buildOptions, watchOptions);
|
|
builder2.build();
|
|
reportSolutionBuilderTimes(builder2, solutionPerformance2);
|
|
reportBuildStatistics = true;
|
|
return builder2;
|
|
}
|
|
const buildHost = createSolutionBuilderHost(
|
|
sys2,
|
|
void 0,
|
|
reportDiagnostic,
|
|
createBuilderStatusReporter(sys2, shouldBePretty(sys2, buildOptions)),
|
|
createReportErrorSummary(sys2, buildOptions)
|
|
);
|
|
const solutionPerformance = enableSolutionPerformance(sys2, buildOptions);
|
|
updateSolutionBuilderHost(sys2, cb, buildHost, solutionPerformance);
|
|
const builder = createSolutionBuilder(buildHost, projects, buildOptions);
|
|
const exitStatus = buildOptions.clean ? builder.clean() : builder.build();
|
|
reportSolutionBuilderTimes(builder, solutionPerformance);
|
|
dumpTracingLegend();
|
|
return sys2.exit(exitStatus);
|
|
}
|
|
function createReportErrorSummary(sys2, options) {
|
|
return shouldBePretty(sys2, options) ? (errorCount, filesInError) => sys2.write(getErrorSummaryText(errorCount, filesInError, sys2.newLine, sys2)) : void 0;
|
|
}
|
|
function performCompilation(sys2, cb, reportDiagnostic, config) {
|
|
const { fileNames, options, projectReferences } = config;
|
|
const host = createCompilerHostWorker(options, void 0, sys2);
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, currentDirectory, getCanonicalFileName));
|
|
enableStatisticsAndTracing(sys2, options, false);
|
|
const programOptions = {
|
|
rootNames: fileNames,
|
|
options,
|
|
projectReferences,
|
|
host,
|
|
configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config)
|
|
};
|
|
const program = createProgram(programOptions);
|
|
const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
|
|
program,
|
|
reportDiagnostic,
|
|
(s) => sys2.write(s + sys2.newLine),
|
|
createReportErrorSummary(sys2, options)
|
|
);
|
|
reportStatistics(sys2, program, void 0);
|
|
cb(program);
|
|
return sys2.exit(exitStatus);
|
|
}
|
|
function performIncrementalCompilation2(sys2, cb, reportDiagnostic, config) {
|
|
const { options, fileNames, projectReferences } = config;
|
|
enableStatisticsAndTracing(sys2, options, false);
|
|
const host = createIncrementalCompilerHost(options, sys2);
|
|
const exitStatus = performIncrementalCompilation({
|
|
host,
|
|
system: sys2,
|
|
rootNames: fileNames,
|
|
options,
|
|
configFileParsingDiagnostics: getConfigFileParsingDiagnostics(config),
|
|
projectReferences,
|
|
reportDiagnostic,
|
|
reportErrorSummary: createReportErrorSummary(sys2, options),
|
|
afterProgramEmitAndDiagnostics: (builderProgram) => {
|
|
reportStatistics(sys2, builderProgram.getProgram(), void 0);
|
|
cb(builderProgram);
|
|
}
|
|
});
|
|
return sys2.exit(exitStatus);
|
|
}
|
|
function updateSolutionBuilderHost(sys2, cb, buildHost, solutionPerformance) {
|
|
updateCreateProgram(sys2, buildHost, true);
|
|
buildHost.afterProgramEmitAndDiagnostics = (program) => {
|
|
reportStatistics(sys2, program.getProgram(), solutionPerformance);
|
|
cb(program);
|
|
};
|
|
buildHost.beforeEmitBundle = (config) => enableStatisticsAndTracing(sys2, config.options, true);
|
|
buildHost.afterEmitBundle = (config) => {
|
|
reportStatistics(sys2, config, solutionPerformance);
|
|
cb(config);
|
|
};
|
|
}
|
|
function updateCreateProgram(sys2, host, isBuildMode) {
|
|
const compileUsingBuilder = host.createProgram;
|
|
host.createProgram = (rootNames, options, host2, oldProgram, configFileParsingDiagnostics, projectReferences) => {
|
|
Debug.assert(rootNames !== void 0 || options === void 0 && !!oldProgram);
|
|
if (options !== void 0) {
|
|
enableStatisticsAndTracing(sys2, options, isBuildMode);
|
|
}
|
|
return compileUsingBuilder(rootNames, options, host2, oldProgram, configFileParsingDiagnostics, projectReferences);
|
|
};
|
|
}
|
|
function updateWatchCompilationHost(sys2, cb, watchCompilerHost) {
|
|
updateCreateProgram(sys2, watchCompilerHost, false);
|
|
const emitFilesUsingBuilder = watchCompilerHost.afterProgramCreate;
|
|
watchCompilerHost.afterProgramCreate = (builderProgram) => {
|
|
emitFilesUsingBuilder(builderProgram);
|
|
reportStatistics(sys2, builderProgram.getProgram(), void 0);
|
|
cb(builderProgram);
|
|
};
|
|
}
|
|
function createWatchStatusReporter2(sys2, options) {
|
|
return createWatchStatusReporter(sys2, shouldBePretty(sys2, options));
|
|
}
|
|
function createWatchOfConfigFile(system, cb, reportDiagnostic, configParseResult, optionsToExtend, watchOptionsToExtend, extendedConfigCache) {
|
|
const watchCompilerHost = createWatchCompilerHostOfConfigFile({
|
|
configFileName: configParseResult.options.configFilePath,
|
|
optionsToExtend,
|
|
watchOptionsToExtend,
|
|
system,
|
|
reportDiagnostic,
|
|
reportWatchStatus: createWatchStatusReporter2(system, configParseResult.options)
|
|
});
|
|
updateWatchCompilationHost(system, cb, watchCompilerHost);
|
|
watchCompilerHost.configFileParsingResult = configParseResult;
|
|
watchCompilerHost.extendedConfigCache = extendedConfigCache;
|
|
return createWatchProgram(watchCompilerHost);
|
|
}
|
|
function createWatchOfFilesAndCompilerOptions(system, cb, reportDiagnostic, rootFiles, options, watchOptions) {
|
|
const watchCompilerHost = createWatchCompilerHostOfFilesAndCompilerOptions({
|
|
rootFiles,
|
|
options,
|
|
watchOptions,
|
|
system,
|
|
reportDiagnostic,
|
|
reportWatchStatus: createWatchStatusReporter2(system, options)
|
|
});
|
|
updateWatchCompilationHost(system, cb, watchCompilerHost);
|
|
return createWatchProgram(watchCompilerHost);
|
|
}
|
|
function enableSolutionPerformance(system, options) {
|
|
if (system === sys && options.extendedDiagnostics) {
|
|
enable();
|
|
return createSolutionPerfomrance();
|
|
}
|
|
}
|
|
function createSolutionPerfomrance() {
|
|
let statistics;
|
|
return {
|
|
addAggregateStatistic,
|
|
forEachAggregateStatistics: forEachAggreateStatistics,
|
|
clear: clear2
|
|
};
|
|
function addAggregateStatistic(s) {
|
|
const existing = statistics == null ? void 0 : statistics.get(s.name);
|
|
if (existing) {
|
|
if (existing.type === 2 /* memory */)
|
|
existing.value = Math.max(existing.value, s.value);
|
|
else
|
|
existing.value += s.value;
|
|
} else {
|
|
(statistics != null ? statistics : statistics = /* @__PURE__ */ new Map()).set(s.name, s);
|
|
}
|
|
}
|
|
function forEachAggreateStatistics(cb) {
|
|
statistics == null ? void 0 : statistics.forEach(cb);
|
|
}
|
|
function clear2() {
|
|
statistics = void 0;
|
|
}
|
|
}
|
|
function reportSolutionBuilderTimes(builder, solutionPerformance) {
|
|
if (!solutionPerformance)
|
|
return;
|
|
if (!isEnabled()) {
|
|
sys.write(Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
|
|
return;
|
|
}
|
|
const statistics = [];
|
|
statistics.push(
|
|
{ name: "Projects in scope", value: getBuildOrderFromAnyBuildOrder(builder.getBuildOrder()).length, type: 1 /* count */ }
|
|
);
|
|
reportSolutionBuilderCountStatistic("SolutionBuilder::Projects built");
|
|
reportSolutionBuilderCountStatistic("SolutionBuilder::Timestamps only updates");
|
|
reportSolutionBuilderCountStatistic("SolutionBuilder::Bundles updated");
|
|
solutionPerformance.forEachAggregateStatistics((s) => {
|
|
s.name = `Aggregate ${s.name}`;
|
|
statistics.push(s);
|
|
});
|
|
forEachMeasure((name, duration) => {
|
|
if (isSolutionMarkOrMeasure(name))
|
|
statistics.push({ name: `${getNameFromSolutionBuilderMarkOrMeasure(name)} time`, value: duration, type: 0 /* time */ });
|
|
});
|
|
disable();
|
|
enable();
|
|
solutionPerformance.clear();
|
|
reportAllStatistics(sys, statistics);
|
|
function reportSolutionBuilderCountStatistic(name) {
|
|
const value = getCount(name);
|
|
if (value) {
|
|
statistics.push({ name: getNameFromSolutionBuilderMarkOrMeasure(name), value, type: 1 /* count */ });
|
|
}
|
|
}
|
|
function getNameFromSolutionBuilderMarkOrMeasure(name) {
|
|
return name.replace("SolutionBuilder::", "");
|
|
}
|
|
}
|
|
function canReportDiagnostics(system, compilerOptions) {
|
|
return system === sys && (compilerOptions.diagnostics || compilerOptions.extendedDiagnostics);
|
|
}
|
|
function canTrace(system, compilerOptions) {
|
|
return system === sys && compilerOptions.generateTrace;
|
|
}
|
|
function enableStatisticsAndTracing(system, compilerOptions, isBuildMode) {
|
|
if (canReportDiagnostics(system, compilerOptions)) {
|
|
enable(system);
|
|
}
|
|
if (canTrace(system, compilerOptions)) {
|
|
startTracing(
|
|
isBuildMode ? "build" : "project",
|
|
compilerOptions.generateTrace,
|
|
compilerOptions.configFilePath
|
|
);
|
|
}
|
|
}
|
|
function isSolutionMarkOrMeasure(name) {
|
|
return startsWith(name, "SolutionBuilder::");
|
|
}
|
|
function isProgram(programOrConfig) {
|
|
return !programOrConfig.options;
|
|
}
|
|
function reportStatistics(sys2, programOrConfig, solutionPerformance) {
|
|
var _a2;
|
|
const program = isProgram(programOrConfig) ? programOrConfig : void 0;
|
|
const config = isProgram(programOrConfig) ? void 0 : programOrConfig;
|
|
const compilerOptions = program ? program.getCompilerOptions() : config.options;
|
|
if (canTrace(sys2, compilerOptions)) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.stopTracing();
|
|
}
|
|
let statistics;
|
|
if (canReportDiagnostics(sys2, compilerOptions)) {
|
|
statistics = [];
|
|
const memoryUsed = sys2.getMemoryUsage ? sys2.getMemoryUsage() : -1;
|
|
if (program) {
|
|
reportCountStatistic("Files", program.getSourceFiles().length);
|
|
const lineCounts = countLines(program);
|
|
if (compilerOptions.extendedDiagnostics) {
|
|
for (const key of arrayFrom(lineCounts.keys())) {
|
|
reportCountStatistic("Lines of " + key, lineCounts.get(key));
|
|
}
|
|
} else {
|
|
reportCountStatistic("Lines", reduceLeftIterator(lineCounts.values(), (sum2, count) => sum2 + count, 0));
|
|
}
|
|
reportCountStatistic("Identifiers", program.getIdentifierCount());
|
|
reportCountStatistic("Symbols", program.getSymbolCount());
|
|
reportCountStatistic("Types", program.getTypeCount());
|
|
reportCountStatistic("Instantiations", program.getInstantiationCount());
|
|
}
|
|
if (memoryUsed >= 0) {
|
|
reportStatisticalValue({ name: "Memory used", value: memoryUsed, type: 2 /* memory */ }, true);
|
|
}
|
|
const isPerformanceEnabled = isEnabled();
|
|
const programTime = isPerformanceEnabled ? getDuration("Program") : 0;
|
|
const bindTime = isPerformanceEnabled ? getDuration("Bind") : 0;
|
|
const checkTime = isPerformanceEnabled ? getDuration("Check") : 0;
|
|
const emitTime = isPerformanceEnabled ? getDuration("Emit") : 0;
|
|
if (compilerOptions.extendedDiagnostics) {
|
|
if (program) {
|
|
const caches = program.getRelationCacheSizes();
|
|
reportCountStatistic("Assignability cache size", caches.assignable);
|
|
reportCountStatistic("Identity cache size", caches.identity);
|
|
reportCountStatistic("Subtype cache size", caches.subtype);
|
|
reportCountStatistic("Strict subtype cache size", caches.strictSubtype);
|
|
}
|
|
if (isPerformanceEnabled) {
|
|
forEachMeasure((name, duration) => {
|
|
if (!isSolutionMarkOrMeasure(name))
|
|
reportTimeStatistic(`${name} time`, duration, true);
|
|
});
|
|
}
|
|
} else if (isPerformanceEnabled) {
|
|
reportTimeStatistic("I/O read", getDuration("I/O Read"), true);
|
|
reportTimeStatistic("I/O write", getDuration("I/O Write"), true);
|
|
reportTimeStatistic("Parse time", programTime, true);
|
|
reportTimeStatistic("Bind time", bindTime, true);
|
|
reportTimeStatistic("Check time", checkTime, true);
|
|
reportTimeStatistic("Emit time", emitTime, true);
|
|
}
|
|
if (isPerformanceEnabled) {
|
|
reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime, false);
|
|
}
|
|
reportAllStatistics(sys2, statistics);
|
|
if (!isPerformanceEnabled) {
|
|
sys2.write(Diagnostics.Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found.message + "\n");
|
|
} else {
|
|
if (solutionPerformance) {
|
|
forEachMeasure((name) => {
|
|
if (!isSolutionMarkOrMeasure(name))
|
|
clearMeasures(name);
|
|
});
|
|
forEachMark((name) => {
|
|
if (!isSolutionMarkOrMeasure(name))
|
|
clearMarks(name);
|
|
});
|
|
} else {
|
|
disable();
|
|
}
|
|
}
|
|
}
|
|
function reportStatisticalValue(s, aggregate) {
|
|
statistics.push(s);
|
|
if (aggregate)
|
|
solutionPerformance == null ? void 0 : solutionPerformance.addAggregateStatistic(s);
|
|
}
|
|
function reportCountStatistic(name, count) {
|
|
reportStatisticalValue({ name, value: count, type: 1 /* count */ }, true);
|
|
}
|
|
function reportTimeStatistic(name, time, aggregate) {
|
|
reportStatisticalValue({ name, value: time, type: 0 /* time */ }, aggregate);
|
|
}
|
|
}
|
|
function reportAllStatistics(sys2, statistics) {
|
|
let nameSize = 0;
|
|
let valueSize = 0;
|
|
for (const s of statistics) {
|
|
if (s.name.length > nameSize) {
|
|
nameSize = s.name.length;
|
|
}
|
|
const value = statisticValue(s);
|
|
if (value.length > valueSize) {
|
|
valueSize = value.length;
|
|
}
|
|
}
|
|
for (const s of statistics) {
|
|
sys2.write(padRight(s.name + ":", nameSize + 2) + padLeft(statisticValue(s).toString(), valueSize) + sys2.newLine);
|
|
}
|
|
}
|
|
function statisticValue(s) {
|
|
switch (s.type) {
|
|
case 1 /* count */:
|
|
return "" + s.value;
|
|
case 0 /* time */:
|
|
return (s.value / 1e3).toFixed(2) + "s";
|
|
case 2 /* memory */:
|
|
return Math.round(s.value / 1e3) + "K";
|
|
default:
|
|
Debug.assertNever(s.type);
|
|
}
|
|
}
|
|
function writeConfigFile(sys2, reportDiagnostic, options, fileNames) {
|
|
const currentDirectory = sys2.getCurrentDirectory();
|
|
const file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
|
|
if (sys2.fileExists(file)) {
|
|
reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file));
|
|
} else {
|
|
sys2.writeFile(file, generateTSConfig(options, fileNames, sys2.newLine));
|
|
const output = [sys2.newLine, ...getHeader(sys2, "Created a new tsconfig.json with:")];
|
|
output.push(getCompilerOptionsDiffValue(options, sys2.newLine) + sys2.newLine + sys2.newLine);
|
|
output.push(`You can learn more at https://aka.ms/tsconfig` + sys2.newLine);
|
|
for (const line of output) {
|
|
sys2.write(line);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// src/tsc/tsc.ts
|
|
Debug.loggingHost = {
|
|
log(_level, s) {
|
|
sys.write(`${s || ""}${sys.newLine}`);
|
|
}
|
|
};
|
|
if (Debug.isDebugging) {
|
|
Debug.enableDebugInfo();
|
|
}
|
|
if (sys.tryEnableSourceMapsForHost && /^development$/i.test(sys.getEnvironmentVariable("NODE_ENV"))) {
|
|
sys.tryEnableSourceMapsForHost();
|
|
}
|
|
if (sys.setBlocking) {
|
|
sys.setBlocking();
|
|
}
|
|
executeCommandLine(sys, noop, sys.args);
|
|
//# sourceMappingURL=tsc.js.map
|